Skip to content

Instantly share code, notes, and snippets.

@libfun

libfun/odessa_dl_0607.ipynb

Created June 7, 2018 12:46
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save libfun/fff8bcf5e3916d49c63d9c704910552b to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save libfun/fff8bcf5e3916d49c63d9c704910552b to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
odessa_dl_0607.ipynb
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"%matplotlib inline\n",
"from tqdm import tqdm, tqdm_notebook\n",
"import os\n",
"from sklearn.datasets import load_digits\n",
"%config InlineBackend.figure_format = 'retina'"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"mnist_data = load_digits()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"mnist_data.keys()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"mnist_data.data[0]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.figure(figsize=(12, 5))\n",
"for i in range(10):\n",
" plt.subplot(1, 10, i + 1)\n",
" plt.imshow(mnist_data.data[i].reshape(8, 8), cmap='gray')\n",
" plt.axis('off')\n",
"plt.show();"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.linear_model import LogisticRegression\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.metrics import accuracy_score"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"X_train, X_test, y_train, y_test = train_test_split(mnist_data.data, mnist_data.target, test_size=.2)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"X_train.shape, X_test.shape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"cls = LogisticRegression()\n",
"cls.fit(X_train, y_train)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"preds = cls.predict(X_test)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"accuracy_score(y_test, preds)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"from torch import nn"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"class ShallowNet(nn.Module):\n",
" def __init__(self):\n",
" super().__init__()\n",
" self.first_layer = nn.Linear(in_features=64, out_features=16)\n",
" self.second_layer = nn.Linear(in_features=16, out_features=10)\n",
" self.output_layer = nn.Softmax(dim=-1)\n",
" \n",
" def forward(self, x):\n",
" out = self.first_layer(x)\n",
" out = self.second_layer(out)\n",
" return self.output_layer(out)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"net = ShallowNet()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(net)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"X_train_tensor = torch.from_numpy(X_train).to(dtype=torch.float32)\n",
"X_test_tensor = torch.from_numpy(X_test).to(dtype=torch.float32)\n",
"y_train_tensor = torch.from_numpy(y_train)\n",
"y_test_tensor = torch.from_numpy(y_test)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"out = net(X_train_tensor)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"pred = out.data.numpy().argmax(axis=1)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"accuracy_score(y_train, pred)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"net = ShallowNet()\n",
"criterion = nn.CrossEntropyLoss()\n",
"optimizer = torch.optim.Adam(net.parameters())\n",
"\n",
"losses_train = []\n",
"losses_test = []\n",
"accs_train = []\n",
"accs_test = []\n",
"\n",
"epoch = 1\n",
"max_epoch = 200\n",
"for i in range(max_epoch):\n",
" optimizer.zero_grad()\n",
" out = net(X_train_tensor)\n",
" pred = out.data.numpy().argmax(axis=1)\n",
" loss = criterion(out, y_train_tensor)\n",
" loss.backward()\n",
" optimizer.step()\n",
" loss_value = loss.data.numpy()\n",
" out_test = net(X_test_tensor)\n",
" losses_train.append(loss_value)\n",
" losses_test.append(criterion(out_test, y_test_tensor).data.numpy())\n",
" accs_train.append(accuracy_score(y_train, pred))\n",
" accs_test.append(accuracy_score(out_test.data.numpy().argmax(axis=1), y_test))\n",
" if i % 10 == 0:\n",
" print('Epoch[{}]: train_loss {:.5f} train_accuracy {:.5f} | test_loss {:.5f} test_accuracy {:.5f}'.format(\n",
" epoch, losses_train[-1], accs_train[-1], \n",
" losses_test[-1], accs_train[-1]))\n",
" epoch += 1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.plot(list(range(max_epoch)), losses_train, label='train loss')\n",
"plt.plot(list(range(max_epoch)), losses_test, label='test loss')\n",
"plt.legend(loc='best')\n",
"plt.show();\n",
"plt.plot(list(range(max_epoch)), accs_train, label='train accuracy')\n",
"plt.plot(list(range(max_epoch)), accs_test, label='test accuracy')\n",
"plt.legend(loc='best')\n",
"plt.show();"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from torch.utils.data import TensorDataset, DataLoader"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"train_loader = DataLoader(TensorDataset(X_train_tensor, y_train_tensor), batch_size=16, shuffle=True)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"net = ShallowNet()\n",
"criterion = nn.CrossEntropyLoss()\n",
"optimizer = torch.optim.Adam(net.parameters())\n",
"\n",
"losses_train = []\n",
"losses_test = []\n",
"accs_train = []\n",
"accs_test = []\n",
"\n",
"epoch = 1\n",
"max_epoch = 200\n",
"for i in range(max_epoch):\n",
" tmp_train_loss = []\n",
" tmp_train_acc = []\n",
" for batch in train_loader:\n",
" optimizer.zero_grad()\n",
" in_tensor = batch[0]\n",
" target_tensor = batch[1]\n",
" out = net(in_tensor)\n",
" pred = out.data.numpy().argmax(axis=1)\n",
" loss = criterion(out, target_tensor)\n",
" loss.backward()\n",
" optimizer.step()\n",
" loss_value = loss.data.numpy()\n",
" tmp_train_loss.append(loss_value)\n",
" tmp_train_acc.append(accuracy_score(target_tensor.data.numpy(), pred))\n",
" out_test = net(X_test_tensor)\n",
" losses_train.append(np.mean(tmp_train_loss))\n",
" losses_test.append(criterion(out_test, y_test_tensor).data.numpy())\n",
" accs_train.append(np.mean(tmp_train_acc))\n",
" accs_test.append(accuracy_score(out_test.data.numpy().argmax(axis=1), y_test))\n",
" if i % 10 == 0:\n",
" print('Epoch[{}]: train_loss {:.5f} train_accuracy {:.5f} | test_loss {:.5f} test_accuracy {:.5f}'.format(\n",
" epoch, losses_train[-1], accs_train[-1], \n",
" losses_test[-1], accs_test[-1]))\n",
" epoch += 1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.plot(list(range(max_epoch)), losses_train, label='train loss')\n",
"plt.plot(list(range(max_epoch)), losses_test, label='test loss')\n",
"plt.legend(loc='best')\n",
"plt.show();\n",
"plt.plot(list(range(max_epoch)), accs_train, label='train accuracy')\n",
"plt.plot(list(range(max_epoch)), accs_test, label='test accuracy')\n",
"plt.legend(loc='best')\n",
"plt.show();"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"class DeepNet(nn.Module):\n",
" def __init__(self):\n",
" super().__init__()\n",
" self.network = nn.Sequential(\n",
" nn.Linear(64, 32),\n",
" nn.ReLU(32),\n",
" nn.Linear(32, 16),\n",
" nn.ReLU(16),\n",
" nn.Linear(16, 10),\n",
" nn.Softmax(dim=-1)\n",
" )\n",
" \n",
" def forward(self, x):\n",
" return self.network(x)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"net = DeepNet()\n",
"print(net)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"net = DeepNet()\n",
"criterion = nn.CrossEntropyLoss()\n",
"optimizer = torch.optim.Adam(net.parameters())\n",
"\n",
"losses_train = []\n",
"losses_test = []\n",
"accs_train = []\n",
"accs_test = []\n",
"\n",
"epoch = 1\n",
"max_epoch = 200\n",
"for i in range(max_epoch):\n",
" tmp_train_loss = []\n",
" tmp_train_acc = []\n",
" for batch in train_loader:\n",
" optimizer.zero_grad()\n",
" in_tensor = batch[0]\n",
" target_tensor = batch[1]\n",
" out = net(in_tensor)\n",
" pred = out.data.numpy().argmax(axis=1)\n",
" loss = criterion(out, target_tensor)\n",
" loss.backward()\n",
" optimizer.step()\n",
" loss_value = loss.data.numpy()\n",
" tmp_train_loss.append(loss_value)\n",
" tmp_train_acc.append(accuracy_score(target_tensor.data.numpy(), pred))\n",
" out_test = net(X_test_tensor)\n",
" losses_train.append(np.mean(tmp_train_loss))\n",
" losses_test.append(criterion(out_test, y_test_tensor).data.numpy())\n",
" accs_train.append(np.mean(tmp_train_acc))\n",
" accs_test.append(accuracy_score(out_test.data.numpy().argmax(axis=1), y_test))\n",
" if i % 10 == 0:\n",
" print('Epoch[{}]: train_loss {:.5f} train_accuracy {:.5f} | test_loss {:.5f} test_accuracy {:.5f}'.format(\n",
" epoch, losses_train[-1], accs_train[-1], \n",
" losses_test[-1], accs_test[-1]))\n",
" epoch += 1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.plot(list(range(max_epoch)), losses_train, label='train loss')\n",
"plt.plot(list(range(max_epoch)), losses_test, label='test loss')\n",
"plt.legend(loc='best')\n",
"plt.show();\n",
"plt.plot(list(range(max_epoch)), accs_train, label='train accuracy')\n",
"plt.plot(list(range(max_epoch)), accs_test, label='test accuracy')\n",
"plt.legend(loc='best')\n",
"plt.show();"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"class ConvNet(nn.Module):\n",
" def __init__(self):\n",
" super().__init__()\n",
" self.network = nn.Sequential(\n",
" nn.Conv2d(1, 8, kernel_size=3, padding=1),\n",
" nn.ReLU(8),\n",
" nn.MaxPool2d(2),\n",
" nn.Conv2d(8, 16, kernel_size=3, padding=1),\n",
" nn.ReLU(16),\n",
" nn.MaxPool2d(2),\n",
" nn.Conv2d(16, 32, kernel_size=2),\n",
" nn.ReLU(32)\n",
" )\n",
" self.linear = nn.Linear(32, 10)\n",
" self.output_layer = nn.Softmax(dim=-1)\n",
" \n",
" def forward(self, x):\n",
" out = self.network(x)\n",
" out = self.linear(out.view(-1, 32))\n",
" return self.output_layer(out)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"net = ConvNet()\n",
"print(net)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"X_train_tensor = torch.from_numpy(X_train.reshape(-1, 1, 8, 8)).to(dtype=torch.float32)\n",
"X_test_tensor = torch.from_numpy(X_test.reshape(-1, 1, 8, 8)).to(dtype=torch.float32)\n",
"train_loader = DataLoader(TensorDataset(X_train_tensor, y_train_tensor), batch_size=16, shuffle=True)\n",
"\n",
"net = ConvNet()\n",
"criterion = nn.CrossEntropyLoss()\n",
"optimizer = torch.optim.Adam(net.parameters())\n",
"\n",
"losses_train = []\n",
"losses_test = []\n",
"accs_train = []\n",
"accs_test = []\n",
"\n",
"epoch = 1\n",
"max_epoch = 50\n",
"for i in range(max_epoch):\n",
" tmp_train_loss = []\n",
" tmp_train_acc = []\n",
" for batch in train_loader:\n",
" optimizer.zero_grad()\n",
" in_tensor = batch[0]\n",
" target_tensor = batch[1]\n",
" out = net(in_tensor)\n",
" pred = out.data.numpy().argmax(axis=1)\n",
" loss = criterion(out, target_tensor)\n",
" loss.backward()\n",
" optimizer.step()\n",
" loss_value = loss.data.numpy()\n",
" tmp_train_loss.append(loss_value)\n",
" tmp_train_acc.append(accuracy_score(target_tensor.data.numpy(), pred))\n",
" out_test = net(X_test_tensor)\n",
" losses_train.append(np.mean(tmp_train_loss))\n",
" losses_test.append(criterion(out_test, y_test_tensor).data.numpy())\n",
" accs_train.append(np.mean(tmp_train_acc))\n",
" accs_test.append(accuracy_score(out_test.data.numpy().argmax(axis=1), y_test))\n",
" if i % 10 == 0:\n",
" print('Epoch[{}]: train_loss {:.5f} train_accuracy {:.5f} | test_loss {:.5f} test_accuracy {:.5f}'.format(\n",
" epoch, losses_train[-1], accs_train[-1], \n",
" losses_test[-1], accs_test[-1]))\n",
" epoch += 1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.plot(list(range(max_epoch)), losses_train, label='train loss')\n",
"plt.plot(list(range(max_epoch)), losses_test, label='test loss')\n",
"plt.legend(loc='best')\n",
"plt.show();\n",
"plt.plot(list(range(max_epoch)), accs_train, label='train accuracy')\n",
"plt.plot(list(range(max_epoch)), accs_test, label='test accuracy')\n",
"plt.legend(loc='best')\n",
"plt.show();"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"from PIL import Image"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from torchvision.datasets import ImageFolder, DatasetFolder\n",
"from torch.utils.data import Dataset\n",
"from torchvision import transforms"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"class CatsAndDogs(Dataset):\n",
" def __init__(self, path, transform):\n",
" super().__init__()\n",
" self.path = path\n",
" self.images = sorted(os.listdir(path))\n",
" self.images = np.array(self.images)[[i.endswith('jpg') for i in self.images]]\n",
" self.transform = transform\n",
" \n",
" def __getitem__(self, item):\n",
" imgpath = os.path.join(self.path, self.images[item])\n",
" target = imgpath.split('/')[-1].split('.')[0]\n",
" if target == 'cat':\n",
" target = torch.tensor(0.0)\n",
" else:\n",
" target = torch.tensor(1.0)\n",
" img = Image.open(imgpath)\n",
" return {'image': self.transform(img), \n",
" 'label': target}\n",
" \n",
" def __len__(self):\n",
" return len(self.images)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"train_loader = DataLoader(CatsAndDogs('/Users/libfun/tmp/dl_pres/data/train_small/',\n",
" transforms.Compose([\n",
" transforms.Resize(224),\n",
" transforms.CenterCrop(224),\n",
" transforms.ToTensor(),\n",
" transforms.Normalize([.5, .5, .5], \n",
" [.5, .5, .5])\n",
" ])), batch_size=16, shuffle=True)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"for i in train_loader:\n",
" img = i['image'].data.numpy()[0].transpose(1, 2, 0)\n",
" img /= 2.\n",
" img += .5\n",
" plt.imshow(img);\n",
" print(i['label'][0])\n",
" break"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"class ConvNet(nn.Module):\n",
" def __init__(self, num_ch=4):\n",
" super().__init__()\n",
" self.num_ch = num_ch\n",
" self.network = nn.Sequential( # 224\n",
" nn.Conv2d(3, self.num_ch, kernel_size=3, padding=1),\n",
" nn.ReLU(self.num_ch),\n",
" nn.MaxPool2d(2), # 112\n",
" nn.Conv2d(self.num_ch, 2 * self.num_ch, kernel_size=3, padding=1),\n",
" nn.ReLU(2 * self.num_ch),\n",
" nn.MaxPool2d(2), # 56\n",
" nn.Conv2d(2 * self.num_ch, 4 * self.num_ch, kernel_size=3, padding=1),\n",
" nn.ReLU(4 * self.num_ch),\n",
" nn.MaxPool2d(2), # 28\n",
" nn.Conv2d(4 * self.num_ch, 8 * self.num_ch, kernel_size=3, padding=1),\n",
" nn.ReLU(8 * self.num_ch),\n",
" nn.MaxPool2d(2), # 14\n",
" nn.Conv2d(8 * self.num_ch, 16 * self.num_ch, kernel_size=3, padding=1),\n",
" nn.ReLU(16 * self.num_ch),\n",
" nn.MaxPool2d(2), # 7\n",
" nn.Conv2d(16 * self.num_ch, 32 * self.num_ch, kernel_size=3, padding=1),\n",
" nn.ReLU(32 * self.num_ch),\n",
" nn.AvgPool2d(7)\n",
" )\n",
" self.linear = nn.Linear(32 * self.num_ch, 1)\n",
" self.output_layer = nn.Sigmoid()\n",
" \n",
" def forward(self, x):\n",
" out = self.network(x)\n",
" out = self.linear(out.view(-1, 32 * self.num_ch))\n",
" return self.output_layer(out)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"X_train_tensor = torch.from_numpy(X_train.reshape(-1, 1, 8, 8)).to(dtype=torch.float32)\n",
"X_test_tensor = torch.from_numpy(X_test.reshape(-1, 1, 8, 8)).to(dtype=torch.float32)\n",
"# train_loader = DataLoader(TensorDataset(X_train_tensor, y_train_tensor), batch_size=16, shuffle=True)\n",
"train_loader = DataLoader(CatsAndDogs('/Users/libfun/tmp/dl_pres/data/train_small/',\n",
" transforms.Compose([\n",
" transforms.Resize(224),\n",
" transforms.RandomCrop(224),\n",
" transforms.ToTensor(),\n",
" transforms.Normalize([.5, .5, .5], \n",
" [.5, .5, .5])\n",
" ])), batch_size=16, shuffle=True)\n",
"\n",
"val_loader = DataLoader(CatsAndDogs('/Users/libfun/tmp/dl_pres/data/val_small/',\n",
" transforms.Compose([\n",
" transforms.Resize(224),\n",
" transforms.CenterCrop(224),\n",
" transforms.ToTensor(),\n",
" transforms.Normalize([.5, .5, .5], \n",
" [.5, .5, .5])\n",
" ])), batch_size=1, shuffle=False)\n",
"\n",
"net = ConvNet()\n",
"criterion = nn.BCELoss()\n",
"optimizer = torch.optim.Adam(net.parameters())\n",
"\n",
"losses_train = []\n",
"losses_test = []\n",
"accs_train = []\n",
"accs_test = []\n",
"\n",
"epoch = 1\n",
"iteration = 0\n",
"for i in range(30):\n",
" log_loss = []\n",
" log_acc = []\n",
" for batch in tqdm_notebook(train_loader):\n",
" optimizer.zero_grad()\n",
" in_tensor = batch['image']\n",
" target_tensor = batch['label'].view(-1, 1)\n",
" out = net(in_tensor)\n",
" pred = out.data.numpy().argmax(axis=1)\n",
" loss = criterion(out, target_tensor)\n",
" loss.backward()\n",
" optimizer.step()\n",
" loss_value = loss.data.numpy()\n",
" log_loss.append(loss_value)\n",
" log_acc.append(accuracy_score(target_tensor.data.numpy(), pred))\n",
" if iteration % 50 == 0:\n",
" log_test_loss = []\n",
" log_test_acc = []\n",
" for batch in val_loader:\n",
" in_tensor = batch['image']\n",
" target_tensor = batch['label'].view(-1, 1)\n",
" out = net(in_tensor)\n",
" pred = out.data.numpy().argmax(axis=1)\n",
" loss = criterion(out, target_tensor)\n",
" log_test_loss.append(loss.data.numpy())\n",
" log_test_acc.append(accuracy_score(target_tensor.data.numpy(), pred))\n",
" print('Epoch[{}]: test_loss {:.5f} test_accuracy {:.5f}'.format(\n",
" epoch, np.mean(log_test_loss), np.mean(log_test_acc)))\n",
" iteration += 1\n",
" epoch += 1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from torchvision.models import resnet18"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"net = resnet18(pretrained=True)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(net)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"net.fc = nn.Sequential(\n",
" nn.Linear(in_features=512, out_features=1),\n",
" nn.Sigmoid())"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"X_train_tensor = torch.from_numpy(X_train.reshape(-1, 1, 8, 8)).to(dtype=torch.float32)\n",
"X_test_tensor = torch.from_numpy(X_test.reshape(-1, 1, 8, 8)).to(dtype=torch.float32)\n",
"# train_loader = DataLoader(TensorDataset(X_train_tensor, y_train_tensor), batch_size=16, shuffle=True)\n",
"train_loader = DataLoader(CatsAndDogs('/Users/libfun/tmp/dl_pres/data/train_small/',\n",
" transforms.Compose([\n",
" transforms.Resize(224),\n",
" transforms.CenterCrop(224),\n",
" transforms.ToTensor(),\n",
" transforms.Normalize([.5, .5, .5], \n",
" [.5, .5, .5])\n",
" ])), batch_size=16, shuffle=True)\n",
"\n",
"val_loader = DataLoader(CatsAndDogs('/Users/libfun/tmp/dl_pres/data/val_small/',\n",
" transforms.Compose([\n",
" transforms.Resize(224),\n",
" transforms.CenterCrop(224),\n",
" transforms.ToTensor(),\n",
" transforms.Normalize([.5, .5, .5], \n",
" [.5, .5, .5])\n",
" ])), batch_size=1, shuffle=False)\n",
"\n",
"# net = ConvNet()\n",
"criterion = nn.BCELoss()\n",
"optimizer = torch.optim.Adam(net.fc.parameters())\n",
"is_training = True\n",
"epoch = 1\n",
"iteration = 0\n",
"for i in range(30):\n",
" log_loss = []\n",
" log_acc = []\n",
" for batch in tqdm_notebook(train_loader):\n",
" optimizer.zero_grad()\n",
" in_tensor = batch['image']\n",
" target_tensor = batch['label'].view(-1, 1)\n",
" out = net(in_tensor)\n",
" pred = out.data.numpy().argmax(axis=1)\n",
" loss = criterion(out, target_tensor)\n",
" loss.backward()\n",
" optimizer.step()\n",
" loss_value = loss.data.numpy()\n",
" log_loss.append(loss_value)\n",
" log_acc.append(accuracy_score(target_tensor.data.numpy(), pred))\n",
" if iteration % 50 == 0:\n",
" # print('Epoch[{}]: train_loss {:.5f} train_accuracy {:.5f}'.format(\n",
" # epoch, np.mean(log_loss), np.mean(log_acc)))\n",
" log_test_loss = []\n",
" log_test_acc = []\n",
" for batch in val_loader:\n",
" in_tensor = batch['image']\n",
" target_tensor = batch['label'].view(-1, 1)\n",
" out = net(in_tensor)\n",
" pred = out.data.numpy().argmax(axis=1)\n",
" loss = criterion(out, target_tensor)\n",
" log_test_loss.append(loss.data.numpy())\n",
" log_test_acc.append(accuracy_score(target_tensor.data.numpy(), pred))\n",
" print('Epoch[{}]: test_loss {:.5f} test_accuracy {:.5f}'.format(\n",
" epoch, np.mean(log_test_loss), np.mean(log_test_acc)))\n",
" iteration += 1\n",
" epoch += 1"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"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.6.5"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment