diff --git "a/notebooks/train.ipynb" "b/notebooks/train.ipynb" --- "a/notebooks/train.ipynb" +++ "b/notebooks/train.ipynb" @@ -4,10 +4,37 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\hiroga\\miniconda3\\envs\\pokemon-palworld-v2\\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" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset({\n", + " features: ['image'],\n", + " num_rows: 34945\n", + "})\n", + "Dataset({\n", + " features: ['image'],\n", + " num_rows: 48837\n", + "})\n" + ] + } + ], "source": [ - "import sys\n", - "sys.path.append('..')\n" + "from datasets import load_dataset\n", + "\n", + "dataset_pal = load_dataset(\"imagefolder\", data_dir=\"../data/filtered/pal\", drop_labels=True, split=\"train\")\n", + "print(dataset_pal)\n", + "dataset_pokemon = load_dataset(\"imagefolder\", data_dir=\"../data/filtered/pokemon\", drop_labels=True, split=\"train\")\n", + "print(dataset_pokemon)" ] }, { @@ -16,255 +43,463 @@ "metadata": {}, "outputs": [], "source": [ - "from torch.utils.data import Dataset\n", - "from PIL import Image\n", - "import os\n", - "from sklearn.model_selection import train_test_split\n", - "\n", - "class PokemonPalDataset(Dataset):\n", - " def __init__(self, image_paths, labels, transform=None):\n", - " self.image_paths = image_paths\n", - " self.labels = labels\n", - " self.transform = transform\n", - "\n", - " def __len__(self):\n", - " return len(self.image_paths)\n", - "\n", - " def __getitem__(self, idx):\n", - " image_path = self.image_paths[idx]\n", - " image = Image.open(image_path).convert('RGB')\n", - " label = self.labels[idx]\n", + "dataset_pal = dataset_pal.map(lambda example: {'label': 0})\n", + "dataset_pokemon = dataset_pokemon.map(lambda example: {'label': 1})" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from datasets import concatenate_datasets\n", "\n", - " if self.transform:\n", - " image = self.transform(image)\n", + "dataset = concatenate_datasets([dataset_pal, dataset_pokemon])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import DataLoader\n", + "from torchvision import transforms\n", "\n", - " return image, label\n", + "compose = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.Lambda(lambda x: x.convert(\"RGB\")),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", + "])\n", + "transformed = dataset.map(lambda example: {\"image\": compose(example[\"image\"])}, batched=False)\n", + "transformed.set_format(\"torch\")\n", + "train_test_dataset = transformed.train_test_split(test_size=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 128\n", + "train_dataloader = DataLoader(train_test_dataset[\"train\"], batch_size=batch_size, shuffle=True)\n", + "test_dataloader = DataLoader(train_test_dataset[\"test\"], batch_size=batch_size, shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "label = [\"pal\", \"pokemon\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import wandb\n", "\n", - "data_dir: str = '../data/cropped/'\n", - "pokemon_dir: list[str] = [\n", - " f\"{data_dir}#Newポケモンスナップ/\",\n", - " f\"{data_dir}ポケットモンスターシールド/\"\n", - "]\n", - "pal_dir: list[str] = [\n", - " f\"{data_dir}/#パルワールド/\", \n", - " f\"{data_dir}/every-pal-in-palworld-a-complete-paldeck-list/\",\n", - " f\"{data_dir}/paldex.io/\"\n", - "]\n", + "def train(model, optimizer, criterion, train_loader, test_loader, num_epochs, device):\n", + " for epoch in range(num_epochs):\n", + " model.train()\n", + " running_loss = 0.0\n", + " running_correct = 0\n", + " total = 0\n", + " \n", + " for batch in train_loader:\n", + " images, labels = batch[\"image\"], batch[\"label\"]\n", + " images, labels = images.to(device), labels.to(device)\n", + " optimizer.zero_grad()\n", + " outputs = model(images)\n", + " _, predicted = torch.max(outputs, 1)\n", + " loss = criterion(outputs, labels)\n", "\n", - "pokemon_images: list[str] = [os.path.join(dir, file) for dir in pokemon_dir for file in os.listdir(dir)]\n", - "pal_images: list[str] = [os.path.join(dir, file) for dir in pal_dir for file in os.listdir(dir)]\n", - "total_images: list[str] = pokemon_images + pal_images\n", - "labels: list = [0] * len(pokemon_images) + [1] * len(pal_images)\n", + " loss.backward()\n", + " optimizer.step()\n", "\n", - "# Split the dataset into train and test sets\n", - "train_images, test_images, train_labels, test_labels = train_test_split(total_images, labels, test_size=0.2, random_state=42)\n", + " running_loss += loss.item()\n", + " running_correct += torch.sum(predicted == labels.data)\n", + " total += len(labels)\n", + " \n", + " model.eval()\n", + " running_test_loss = 0.0\n", + " running_test_correct = 0\n", + " test_total = 0\n", + " \n", + " with torch.no_grad():\n", + " for batch in train_loader:\n", + " images, labels = batch[\"image\"], batch[\"label\"]\n", + " images, labels = images.to(device), labels.to(device)\n", + " outputs = model(images)\n", + " _, predicted = torch.max(outputs, 1)\n", + " loss = criterion(outputs, labels)\n", + " test_total += len(labels)\n", "\n", - "train_dataset = PokemonPalDataset(train_images, train_labels)\n", - "test_dataset = PokemonPalDataset(test_images, test_labels)\n" + " running_test_loss += loss.item()\n", + " running_test_correct += torch.sum(predicted == labels.data)\n", + " \n", + " log = {\n", + " \"epoch\": epoch +1,\n", + " \"train_loss\": running_loss / len(train_loader),\n", + " \"train_acc\": running_correct / total,\n", + " \"test_loss\": running_test_loss / len(test_loader),\n", + " \"test_acc\": running_test_correct / test_total\n", + " }\n", + " print(log)\n", + " wandb.log(log)\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "c:\\Users\\hiroga\\miniconda3\\envs\\til-machine-learning\\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" + "Failed to detect the name of this notebook, you can set it manually with the WANDB_NOTEBOOK_NAME environment variable to enable code saving.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mhiroga\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total images: 372\n", - "Number of Pokemon images: 217\n", - "Number of Pal images: 155\n", - "Train dataset size: 297\n", - "Test dataset size: 75\n" - ] + "data": { + "text/html": [ + "Tracking run with wandb version 0.16.3" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { "data": { - "image/png": "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", + "text/html": [ + "Run data is saved locally in c:\\Users\\hiroga\\Documents\\GitHub\\til\\computer-science\\machine-learning\\_src\\pokemon-palworld\\notebooks\\wandb\\run-20240222_085816-qrvtmdob" + ], "text/plain": [ - "
" + "" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run glowing-rooster-39 to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://wandb.ai/hiroga/pokemon-palworld" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://wandb.ai/hiroga/pokemon-palworld/runs/qrvtmdob" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\hiroga\\miniconda3\\envs\\pokemon-palworld-v2\\Lib\\site-packages\\torchvision\\models\\_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n", + " warnings.warn(\n", + "c:\\Users\\hiroga\\miniconda3\\envs\\pokemon-palworld-v2\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.\n", + " warnings.warn(msg)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'epoch': 1, 'train_loss': 0.05833915864536894, 'train_acc': tensor(0.9789, device='cuda:0'), 'test_loss': 0.11876845688253414, 'test_acc': tensor(0.9912, device='cuda:0')}\n", + "{'epoch': 2, 'train_loss': 0.03478731791966929, 'train_acc': tensor(0.9890, device='cuda:0'), 'test_loss': 0.10162574984133244, 'test_acc': tensor(0.9923, device='cuda:0')}\n", + "{'epoch': 3, 'train_loss': 0.03210982568926384, 'train_acc': tensor(0.9901, device='cuda:0'), 'test_loss': 0.09957705784894753, 'test_acc': tensor(0.9918, device='cuda:0')}\n", + "{'epoch': 4, 'train_loss': 0.029581266190529667, 'train_acc': tensor(0.9904, device='cuda:0'), 'test_loss': 0.11058470348379652, 'test_acc': tensor(0.9923, device='cuda:0')}\n", + "{'epoch': 5, 'train_loss': 0.029816618186993993, 'train_acc': tensor(0.9903, device='cuda:0'), 'test_loss': 0.08752415181166058, 'test_acc': tensor(0.9933, device='cuda:0')}\n", + "{'epoch': 1, 'train_loss': 0.020498616995582294, 'train_acc': tensor(0.9938, device='cuda:0'), 'test_loss': 0.05274752890984421, 'test_acc': tensor(0.9964, device='cuda:0')}\n", + "{'epoch': 2, 'train_loss': 0.013660616503107782, 'train_acc': tensor(0.9960, device='cuda:0'), 'test_loss': 0.03897114609966218, 'test_acc': tensor(0.9975, device='cuda:0')}\n", + "{'epoch': 3, 'train_loss': 0.011321998002304863, 'train_acc': tensor(0.9969, device='cuda:0'), 'test_loss': 0.03173145028017817, 'test_acc': tensor(0.9981, device='cuda:0')}\n", + "{'epoch': 4, 'train_loss': 0.009109769900116575, 'train_acc': tensor(0.9977, device='cuda:0'), 'test_loss': 0.025280542672569118, 'test_acc': tensor(0.9987, device='cuda:0')}\n", + "{'epoch': 5, 'train_loss': 0.00814158867722251, 'train_acc': tensor(0.9977, device='cuda:0'), 'test_loss': 0.021063973103984942, 'test_acc': tensor(0.9989, device='cuda:0')}\n" + ] } ], "source": [ - "from torchvision import transforms\n", + "# Fine Tuning from ResNet18\n", + "import torchvision.models as models\n", + "import wandb\n", + "from datetime import datetime\n", + "from safetensors.torch import save_file\n", "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import torchvision\n", + "model_name = \"ResNet18_FineTuned\"\n", + "last_layer_learning_rate = 0.01\n", + "last_layer_momentum = 0.9\n", + "last_layer_epoches = 5\n", + "full_layer_learning_rate = 0.001\n", + "full_layer_momentum = 0.001\n", + "full_layer_epoches = 5\n", "\n", - "# Data Summary\n", - "print(f\"Total images: {len(total_images)}\")\n", - "print(f\"Number of Pokemon images: {len(pokemon_images)}\")\n", - "print(f\"Number of Pal images: {len(pal_images)}\")\n", - "print(f\"Train dataset size: {len(train_dataset)}\")\n", - "print(f\"Test dataset size: {len(test_dataset)}\")\n", + "wandb.init(\n", + " project=\"pokemon-palworld\",\n", + " config={\n", + " \"model_name\": model_name,\n", + " \"labels\": label,\n", + " \"last_layer_learning_rate\": last_layer_learning_rate,\n", + " \"last_layer_momentum\": last_layer_momentum,\n", + " \"last_layer_epochs\": last_layer_epoches,\n", + " \"full_layer_learning_rate\": full_layer_learning_rate,\n", + " \"full_layer_momentum\": full_layer_momentum,\n", + " \"full_layer_epochs\": full_layer_epoches,\n", + " \"architecture\": \"CNN\",\n", + " \"dataset\": \"pokemon-palworld\",\n", + " \"train_size\": len(train_dataloader.dataset),\n", + " \"test_size\": len(test_dataloader.dataset),\n", + " \"batch_size\": batch_size,\n", + " }\n", + ")\n", "\n", - "# Show a transformed image sample from the dataset\n", - "def imshow(img, title):\n", - " npimg = img.numpy()\n", - " plt.figure(figsize=(6, 6))\n", - " plt.imshow(np.transpose(npimg, (1, 2, 0)))\n", - " plt.title(title)\n", - " plt.show()\n", + "model = models.resnet18(pretrained=True)\n", + "for param in model.parameters():\n", + " param.requires_grad = False\n", + "model.fc = torch.nn.Linear(model.fc.in_features, len(label))\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "model.to(device)\n", "\n", - "# Show images\n", - "train_dataset.transform = transforms.Compose([\n", - " transforms.Resize((64, 64)),\n", - " transforms.ToTensor(),\n", - "])\n", + "criterion = torch.nn.CrossEntropyLoss()\n", + "\n", + "# Fine-tune the last layer for a few epochs\n", + "optimizer = torch.optim.SGD(model.fc.parameters(), lr=last_layer_learning_rate, momentum=last_layer_momentum)\n", + "train(model, optimizer, criterion, train_dataloader, test_dataloader, num_epochs=last_layer_epoches, device=device)\n", "\n", - "sample_indices = np.random.choice(len(train_dataset), 16)\n", - "sample_images = [train_dataset[i][0] for i in sample_indices]\n", - "out = torchvision.utils.make_grid(sample_images)\n", - "imshow(out, title=\"Sample Images\")\n" + "# Unfreeze all the layers and fine-tune the entire network for a few more epochs\n", + "for param in model.parameters():\n", + " param.requires_grad = True\n", + "optimizer = torch.optim.SGD(model.parameters(), lr=full_layer_learning_rate, momentum=full_layer_momentum)\n", + "train(model, optimizer, criterion, train_dataloader, test_dataloader, num_epochs=full_layer_epoches, device=device)\n", + "\n", + "save_file(model.state_dict(), f\"../models/snapshots/{model_name}_epoch{last_layer_epoches}_{full_layer_epoches}_{datetime.now().strftime('%Y%m%d%H%M%S')}.safetensors\")" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1: Train Loss = 4.574430512754541, Test Loss = 0.6880495309829712\n", - "Epoch 2: Train Loss = 0.6884251707478574, Test Loss = 0.68654705286026\n", - "Epoch 3: Train Loss = 0.6871375347438612, Test Loss = 0.6855929136276245\n", - "Epoch 4: Train Loss = 0.6845650233720478, Test Loss = 0.676890778541565\n", - "Epoch 5: Train Loss = 0.6760753487285814, Test Loss = 0.6653171062469483\n" - ] + "data": { + "text/html": [ + "Finishing last run (ID:qrvtmdob) before initializing another..." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "

Run history:


epoch▁▃▅▆█▁▃▅▆█
test_acc▁▂▂▂▃▆▇▇██
test_loss█▇▇▇▆▃▂▂▁▁
train_acc▁▅▅▅▅▇▇███
train_loss█▅▄▄▄▃▂▁▁▁

Run summary:


epoch5
test_acc0.9989
test_loss0.02106
train_acc0.99773
train_loss0.00814

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { "data": { - "image/png": "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", + "text/html": [ + " View run glowing-rooster-39 at: https://wandb.ai/hiroga/pokemon-palworld/runs/qrvtmdob
Synced 5 W&B file(s), 0 media file(s), 0 artifact file(s) and 0 other file(s)" + ], "text/plain": [ - "
" + "" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Find logs at: .\\wandb\\run-20240222_085816-qrvtmdob\\logs" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Successfully finished last run (ID:qrvtmdob). Initializing new run:
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.16.3" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in c:\\Users\\hiroga\\Documents\\GitHub\\til\\computer-science\\machine-learning\\_src\\pokemon-palworld\\notebooks\\wandb\\run-20240222_114545-7hknvmoi" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run dazzling-paper-40 to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://wandb.ai/hiroga/pokemon-palworld" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://wandb.ai/hiroga/pokemon-palworld/runs/7hknvmoi" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "ename": "ValueError", + "evalue": "Expected input batch_size (98) to match target batch_size (128).", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[10], line 37\u001b[0m\n\u001b[0;32m 34\u001b[0m optimizer \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39moptim\u001b[38;5;241m.\u001b[39mAdam(model\u001b[38;5;241m.\u001b[39mparameters(), lr\u001b[38;5;241m=\u001b[39mlearning_rate)\n\u001b[0;32m 35\u001b[0m criterion \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mnn\u001b[38;5;241m.\u001b[39mCrossEntropyLoss()\n\u001b[1;32m---> 37\u001b[0m \u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcriterion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_dataloader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest_dataloader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_epochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mepochs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 39\u001b[0m save_file(model\u001b[38;5;241m.\u001b[39mstate_dict(), \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m../models/snapshots/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodel_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m_epoch\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepochs\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.safetensors\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "Cell \u001b[1;32mIn[7], line 17\u001b[0m, in \u001b[0;36mtrain\u001b[1;34m(model, optimizer, criterion, train_loader, test_loader, num_epochs, device)\u001b[0m\n\u001b[0;32m 15\u001b[0m outputs \u001b[38;5;241m=\u001b[39m model(images)\n\u001b[0;32m 16\u001b[0m _, predicted \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mmax(outputs, \u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m---> 17\u001b[0m loss \u001b[38;5;241m=\u001b[39m \u001b[43mcriterion\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabels\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 19\u001b[0m loss\u001b[38;5;241m.\u001b[39mbackward()\n\u001b[0;32m 20\u001b[0m optimizer\u001b[38;5;241m.\u001b[39mstep()\n", + "File \u001b[1;32mc:\\Users\\hiroga\\miniconda3\\envs\\pokemon-palworld-v2\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32mc:\\Users\\hiroga\\miniconda3\\envs\\pokemon-palworld-v2\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[1;32mc:\\Users\\hiroga\\miniconda3\\envs\\pokemon-palworld-v2\\Lib\\site-packages\\torch\\nn\\modules\\loss.py:1179\u001b[0m, in \u001b[0;36mCrossEntropyLoss.forward\u001b[1;34m(self, input, target)\u001b[0m\n\u001b[0;32m 1178\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor, target: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[1;32m-> 1179\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcross_entropy\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mweight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1180\u001b[0m \u001b[43m \u001b[49m\u001b[43mignore_index\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mignore_index\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreduction\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreduction\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1181\u001b[0m \u001b[43m \u001b[49m\u001b[43mlabel_smoothing\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlabel_smoothing\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32mc:\\Users\\hiroga\\miniconda3\\envs\\pokemon-palworld-v2\\Lib\\site-packages\\torch\\nn\\functional.py:3059\u001b[0m, in \u001b[0;36mcross_entropy\u001b[1;34m(input, target, weight, size_average, ignore_index, reduce, reduction, label_smoothing)\u001b[0m\n\u001b[0;32m 3057\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m size_average \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m reduce \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 3058\u001b[0m reduction \u001b[38;5;241m=\u001b[39m _Reduction\u001b[38;5;241m.\u001b[39mlegacy_get_string(size_average, reduce)\n\u001b[1;32m-> 3059\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_C\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_nn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcross_entropy_loss\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_Reduction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_enum\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreduction\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mignore_index\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabel_smoothing\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[1;31mValueError\u001b[0m: Expected input batch_size (98) to match target batch_size (128)." + ] } ], "source": [ + "# SimpleCNN\n", + "import sys\n", + "\n", + "sys.path.append('..')\n", + "\n", "import torch\n", - "import os\n", - "from torch.utils.data import DataLoader\n", - "from torchvision import transforms\n", - "from utils.SimpleCNN import SimpleCNN\n", + "import wandb\n", "from safetensors.torch import save_file\n", "\n", - "# Training code\n", - "def train(model, optimizer, criterion, train_loader, test_loader, num_epochs, device):\n", - " tensors = {}\n", - " train_losses = []\n", - " test_losses = []\n", - " for epoch in range(num_epochs):\n", - " running_loss = 0.0\n", - " running_test_loss = 0.0\n", - " model.train()\n", - " for images, labels in train_loader:\n", - " images, labels = images.to(device), labels.to(device)\n", - " optimizer.zero_grad()\n", - " outputs = model(images)\n", - " loss = criterion(outputs, labels)\n", - " loss.backward()\n", - " optimizer.step()\n", - " running_loss += loss.item()\n", - " \n", - " model.eval()\n", - " with torch.no_grad():\n", - " for images, labels in test_loader:\n", - " images, labels = images.to(device), labels.to(device)\n", - " outputs = model(images)\n", - " loss = criterion(outputs, labels)\n", - " running_test_loss += loss.item()\n", - " \n", - " train_losses.append(running_loss/len(train_loader))\n", - " test_losses.append(running_test_loss/len(test_loader))\n", - " print(f\"Epoch {epoch+1}: Train Loss = {train_losses[-1]}, Test Loss = {test_losses[-1]}\")\n", - " \n", - " # Save the model\n", - " model_dir = '../models/'\n", - " snapshots_dir = f\"{model_dir}snapshots/\"\n", - " if not os.path.exists(snapshots_dir):\n", - " os.makedirs(snapshots_dir)\n", - " tensors = {name: param for name, param in model.named_parameters()}\n", - " save_file(tensors, f\"{snapshots_dir}SimpleCNN_{epoch+1}_{data_dir.replace('.', '').replace('/', '_')}_{image_size}x{image_size}.safetensors\")\n", - " save_file(tensors, f\"{model_dir}model.safetensors\")\n", - "\n", - " # Plotting the losses\n", - " plt.figure(figsize=(10,5))\n", - " plt.title(\"Training and Test Loss\")\n", - " plt.plot(train_losses,label=\"Train\")\n", - " plt.plot(test_losses,label=\"Test\")\n", - " plt.xlabel(\"iterations\")\n", - " plt.ylabel(\"Loss\")\n", - " plt.legend()\n", - " plt.show()\n", + "from src.SimpleCNN import SimpleCNN\n", "\n", + "model_name = \"SimpleCNN\"\n", + "learning_rate = 0.001\n", + "epochs = 5\n", "image_size = 256\n", "\n", - "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "wandb.init(\n", + " project=\"pokemon-palworld\",\n", + " config={\n", + " \"model_name\": model_name,\n", + " \"learning_rate\": learning_rate,\n", + " \"architecture\": \"CNN\",\n", + " \"dataset\": \"pokemon-palworld\",\n", + " \"epochs\": epochs,\n", + " \"image_size\": image_size,\n", + " \"train_size\": len(train_dataloader.dataset),\n", + " \"test_size\": len(test_dataloader.dataset),\n", + " \"batch_size\": batch_size,\n", + " }\n", + ")\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "model = SimpleCNN(image_size=image_size).to(device)\n", - "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n", "criterion = torch.nn.CrossEntropyLoss()\n", "\n", - "transform = transforms.Compose([\n", - " transforms.Resize((image_size, image_size)),\n", - " transforms.ToTensor(),\n", - "])\n", - "train_dataset.transform = transform\n", - "test_dataset.transform = transform\n", - "train_dataloader = DataLoader(train_dataset, batch_size=16, shuffle=True)\n", - "test_dataloader = DataLoader(test_dataset, batch_size=16, shuffle=False)\n", - "\n", - "# Fixing the batch size mismatch error\n", - "train(model, optimizer, criterion, train_dataloader, test_dataloader, num_epochs=5, device=device)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "def imshow(img):\n", - " img = img / 2 + 0.5 # unnormalize\n", - " npimg = img.numpy()\n", - " plt.imshow(np.transpose(npimg, (1, 2, 0)))\n", - " plt.show()\n", - "\n", - "model.eval()\n", - "with torch.no_grad():\n", - " for i, data in enumerate(test_dataloader, 0):\n", - " images, labels = data\n", - " images, labels = images.to(device), labels.to(device)\n", - " outputs = model(images)\n", - " _, predicted = torch.max(outputs.data, 1)\n", + "train(model, optimizer, criterion, train_dataloader, test_dataloader, num_epochs=epochs, device=device)\n", "\n", - " # print images\n", - " for i in range(len(images)):\n", - " imshow(images.cpu()[i])\n", - " print('GroundTruth: ', labels[i])\n", - " print('Output: ', outputs[i])\n", - "\n" + "save_file(model.state_dict(), f\"../models/snapshots/{model_name}_epoch{epochs}.safetensors\")" ] }, { @@ -291,7 +526,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.12.1" } }, "nbformat": 4,