Delete rnn.ipynb

rnn.ipynb

@@ -1,446 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "None\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(torch.version.cuda)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "torch.cuda.empty_cache()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "8"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import multiprocessing\n",
-    "import os\n",
-    "\n",
-    "# CPU コア数を取得（物理コア数）\n",
-    "num_cpu = multiprocessing.cpu_count()\n",
-    "num_workers = min(num_cpu - 1, 8)  # 1コアは他の処理用に残す\n",
-    "num_workers"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "NVIDIA GeForce RTX 4060 Laptop GPU\n",
-      "0\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(torch.cuda.get_device_name(torch.cuda.current_device()))\n",
-    "print(torch.cuda.memory_allocated())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "テキストデータのTensor化\n",
-    "1. テキストの読み込み\n",
-    "2. テキストのトークン化\n",
-    "3. トークンのインデックス化\n",
-    "4. 複数テキストのバッチ化\n",
-    "5. テキストの単語ベクトル化"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "c:\\Users\\kenta\\AppData\\Local\\Programs\\Python\\workspace_env\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    }
-   ],
-   "source": [
-    "import torch\n",
-    "import torch.nn as nn\n",
-    "from torch.utils.data import DataLoader, Dataset, random_split\n",
-    "from transformers import AutoTokenizer\n",
-    "from datasets import load_dataset\n",
-    "import torch.optim as optim\n",
-    "from tqdm import tqdm"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "True\n",
-      "1\n",
-      "0\n",
-      "NVIDIA GeForce RTX 4060 Laptop GPU\n",
-      "(8, 9)\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(torch.cuda.is_available())\n",
-    "print(torch.cuda.device_count())\n",
-    "print(torch.cuda.current_device())\n",
-    "print(torch.cuda.get_device_name())\n",
-    "print(torch.cuda.get_device_capability())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# データセットのロード\n",
-    "dataset = load_dataset(\"stanfordnlp/imdb\")\n",
-    "train_texts = dataset['train']['text'][:100]\n",
-    "train_labels = dataset['train']['label'][100:]\n",
-    "test_texts = dataset['test']['text'][100:]\n",
-    "test_labels = dataset['test']['label'][100:]\n",
-    "\n",
-    "# トークナイザーの準備\n",
-    "tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')\n",
-    "\n",
-    "# テキストのトークン化とインデックス化\n",
-    "def tokenize_function(text_dataset):\n",
-    "    return tokenizer(text_dataset['text'], \n",
-    "                     padding=True,\n",
-    "                     truncation=True,\n",
-    "                     max_length=256)\n",
-    "\n",
-    "train_encodings = dataset['train'].map(tokenize_function, batched=True)\n",
-    "test_encodings = dataset['test'].map(tokenize_function, batched=True)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "# カスタムデータセットクラス\n",
-    "class CustomDataset(Dataset):\n",
-    "    def __init__(self, encodings, labels):\n",
-    "        self.encodings = encodings\n",
-    "        self.labels = labels\n",
-    "    \n",
-    "    def __getitem__(self, idx):\n",
-    "        item = {\n",
-    "            'input_ids': torch.tensor(self.encodings['input_ids'][idx]),\n",
-    "            'attention_mask': torch.tensor(self.encodings['attention_mask'][idx])\n",
-    "        }\n",
-    "        item['labels'] = torch.tensor(self.labels[idx])\n",
-    "        return item\n",
-    "    \n",
-    "    def __len__(self):\n",
-    "        return len(self.labels)\n",
-    "\n",
-    "train_dataset = CustomDataset(train_encodings, train_labels)\n",
-    "test_dataset = CustomDataset(test_encodings, test_labels)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "# 訓練データをtrainとvalに分割\n",
-    "train_size = int(0.7 * len(train_dataset))\n",
-    "val_size = len(train_dataset) - train_size\n",
-    "train_dataset, val_dataset = random_split(train_dataset, [train_size, val_size])\n",
-    "\n",
-    "# データローダー\n",
-    "train_loader = DataLoader(train_dataset, \n",
-    "                          batch_size=64, \n",
-    "                          shuffle=True,\n",
-    "                          num_workers=8,  # 並列データロード\n",
-    "                          pin_memory=True,  # GPUへの転送を高速化\n",
-    "                          prefetch_factor=2  # 先読み\n",
-    "                          )\n",
-    "val_loader = DataLoader(val_dataset, \n",
-    "                          batch_size=64, \n",
-    "                          shuffle=False,\n",
-    "                          num_workers=8,  # 並列データロード\n",
-    "                          pin_memory=True,  # GPUへの転送を高速化\n",
-    "                          prefetch_factor=2  # 先読み\n",
-    "                          )\n",
-    "test_loader = DataLoader(test_dataset,\n",
-    "                          batch_size=64, \n",
-    "                          shuffle=False,\n",
-    "                          num_workers=8,  # 並列データロード\n",
-    "                          pin_memory=True,  # GPUへの転送を高速化\n",
-    "                          prefetch_factor=2  # 先読み\n",
-    "                          )\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "# LSTMモデルの定義\n",
-    "class LstmClassifier(nn.Module):\n",
-    "    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim, num_layers=2, dropout=0.5):\n",
-    "        super(LstmClassifier, self).__init__()\n",
-    "        \n",
-    "        # 埋め込み層を追加\n",
-    "        self.embedding = nn.Embedding(vocab_size, embedding_dim)\n",
-    "        \n",
-    "        # LSTM層\n",
-    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers, batch_first=True)\n",
-    "        self.dropout = nn.Dropout(dropout)\n",
-    "        self.fc = nn.Linear(hidden_dim, output_dim)\n",
-    "        self.softmax = nn.Softmax(dim=1)\n",
-    "    \n",
-    "    def forward(self, x):\n",
-    "        # 埋め込み層を通す\n",
-    "        embedded = self.embedding(x)  # (batch_size, seq_length, embedding_dim)\n",
-    "        \n",
-    "        # LSTM層\n",
-    "        lstm_out, (hn, cn) = self.lstm(embedded)\n",
-    "        final_hidden_state = hn[-1]\n",
-    "        \n",
-    "        # ドロップアウトと全結合層\n",
-    "        x = self.dropout(final_hidden_state)\n",
-    "        x = self.fc(x)\n",
-    "        return self.softmax(x)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "# モデルのインスタンスを作成\n",
-    "# input_dim = tokenizer.model_max_length  # bertの埋め込みサイズ\n",
-    "vocab_size = tokenizer.vocab_size  # トークナイザーの語彙サイズ\n",
-    "embedding_dim = 300  # 埋め込みベクトルの次元数\n",
-    "hidden_dim = 128\n",
-    "output_dim = 2\n",
-    "model = LstmClassifier(vocab_size, embedding_dim, hidden_dim, output_dim)\n",
-    "\n",
-    "# 最適化手法と損失関数\n",
-    "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
-    "criterion = nn.CrossEntropyLoss()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "cuda\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "LstmClassifier(\n",
-       "  (embedding): Embedding(30522, 300)\n",
-       "  (lstm): LSTM(300, 128, num_layers=2, batch_first=True)\n",
-       "  (dropout): Dropout(p=0.5, inplace=False)\n",
-       "  (fc): Linear(in_features=128, out_features=2, bias=True)\n",
-       "  (softmax): Softmax(dim=1)\n",
-       ")"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# 学習ループ\n",
-    "num_epochs = 1\n",
-    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
-    "print(device)\n",
-    "\n",
-    "model.to(device)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "for epoch in range(num_epochs):\n",
-    "    model.train()\n",
-    "    running_loss = 0.0\n",
-    "    for batch in train_loader:\n",
-    "        optimizer.zero_grad()\n",
-    "        # データをGPUに転送\n",
-    "        input_ids = batch['input_ids'].to(device)\n",
-    "        attention_mask = batch['attention_mask'].to(device)\n",
-    "        labels = batch['labels'].to(device)\n",
-    "        # LSTMモデルの予測\n",
-    "        outputs = model(input_ids)  # shape:(batch_size, output_dim)\n",
-    "        \n",
-    "        loss = criterion(outputs, labels)\n",
-    "        loss.backward()\n",
-    "        optimizer.step()\n",
-    "\n",
-    "        running_loss += loss.item()\n",
-    "\n",
-    "    print(f\"Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader)}\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "# バリデーションでの評価\n",
-    "model.eval()\n",
-    "correct = 0\n",
-    "total = 0\n",
-    "with torch.no_grad():\n",
-    "    for batch in tqdm(val_loader):\n",
-    "        input_ids = batch['input_ids'].to(device)\n",
-    "        attention_mask = batch['attention_mask'].to(device)\n",
-    "        labels = batch['labels'].to(device)\n",
-    "        # LSTMモデルの予測\n",
-    "        outputs = model(input_ids)\n",
-    "        _, predicted = torch.max(outputs, dim=1)\n",
-    "\n",
-    "        total += labels.size(0)\n",
-    "        correct += (predicted == labels).sum().item()\n",
-    "val_accuracy = correct / total\n",
-    "print(f\"Validation Accuracy: {val_accuracy * 100:.2f}%\")\n",
-    "\n",
-    "\n",
-    "# モデルの保存\n",
-    "torch.save(model.state_dict(), 'LstmClassifier.pth')\n",
-    "print(\"Model saved!\")\n",
-    "\n",
-    "# # モデルの状態をPickle形式で保存\n",
-    "# import pickle\n",
-    "# with open(\"model.pkl\", \"wb\") as f:\n",
-    "#     pickle.dump(model.state_dict(), f)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "# 保存したモデルの読み込み\n",
-    "model = LstmClassifier(input_dim, hidden_dim, output_dim)\n",
-    "model.load_state_dict(torch.load(\"LstmClassifier.pth\"))\n",
-    "model.to(device)\n",
-    "print(\"Model loaded!\")\n",
-    "\n",
-    "# # Pickleファイルからモデルの状態を読み込む\n",
-    "# import pickle\n",
-    "# with open(\"model.pkl\", \"rb\") as f:\n",
-    "#     model_state_dict = pickle.load(f)\n",
-    "\n",
-    "# # モデルに状態を読み込む\n",
-    "# model.load_state_dict(model_state_dict)\n",
-    "# model.to(device)\n",
-    "\n",
-    "model.eval()\n",
-    "correct = 0\n",
-    "total = 0\n",
-    "with torch.no_grad():\n",
-    "    for batch in test_loader:\n",
-    "        input_ids = batch['input_ids'].to(device)\n",
-    "        attention_mask = batch['attention_mask'].to(device)\n",
-    "        labels = batch['labels'].to(device)\n",
-    "        \n",
-    "        outputs = model(input_ids)\n",
-    "        _, predicted = torch.max(outputs, 1)\n",
-    "        \n",
-    "        total += labels.size(0)\n",
-    "        correct += (predicted == labels).sum().item()\n",
-    "\n",
-    "test_accuracy = correct / total\n",
-    "print(f'Test Accuracy: {test_accuracy * 100:.2f}%')\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "workspace_env",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}