diff --git a/notebooks/01_basics.ipynb b/notebooks/01_basics.ipynb new file mode 100644 index 0000000..88ca9b6 --- /dev/null +++ b/notebooks/01_basics.ipynb @@ -0,0 +1,116 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "x_data = [1.0, 2.0, 3.0]\n", + "y_data = [2.0, 4.0, 6.0]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# our model for the forward pass\n", + "def forward(x):\n", + " return x * w\n", + "\n", + "\n", + "# Loss function\n", + "def loss(x, y):\n", + " y_pred = forward(x)\n", + " return (y_pred - y)**2" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "w_list = []\n", + "mse_list = []\n", + "\n", + "for w in np.arange(0.0, 4.1, 0.1):\n", + " #print(\"w=\", w)\n", + " l_sum = 0\n", + " for x_val, y_val in zip(x_data, y_data):\n", + " y_pred_val = forward(x_val)\n", + " l = loss(x_val, y_val)\n", + " l_sum += l\n", + " #print(\"\\t\", x_val, y_val, y_pred_val, l)\n", + " #print(\"MSE=\", l_sum / 3)\n", + " w_list.append(w)\n", + " mse_list.append(l_sum / 3)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(w_list, mse_list)\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('w')\n", + "plt.title(\"Loss vs Weight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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 +} diff --git a/notebooks/02_manual_gradient.ipynb b/notebooks/02_manual_gradient.ipynb new file mode 100644 index 0000000..d859b6e --- /dev/null +++ b/notebooks/02_manual_gradient.ipynb @@ -0,0 +1,111 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "x_data = [1.0, 2.0, 3.0]\n", + "y_data = [2.0, 4.0, 6.0]\n", + "\n", + "w = 1.0 # a random guess: random value" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# our model forward pass\n", + "\n", + "def forward(x):\n", + " return x * w\n", + "\n", + "# Loss function\n", + "def loss(x, y):\n", + " y_pred = forward(x)\n", + " return (y_pred - y)**2\n", + "\n", + "# compute gradient\n", + "def gradient(x, y): # d_loss/d_w\n", + " return 2 * x * (x * w - y)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predict (before training) 4 , 4.0\n" + ] + } + ], + "source": [ + "# Before training\n", + "print(\"predict (before training)\", 4, ',',forward(4))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predict (after training) 4 , 7.804863933862125\n" + ] + } + ], + "source": [ + "# Training loop\n", + "for epoch in range(10):\n", + " for x_val, y_val in zip(x_data, y_data):\n", + " grad = gradient(x_val, y_val)\n", + " w = w - 0.01 * grad\n", + " #print(\"\\tgrad: \", x_val, y_val, round(grad, 2))\n", + " l = loss(x_val, y_val)\n", + "\n", + " #print(\"progress:\", epoch, \"w=\", round(w, 2), \"loss=\", round(l, 2))\n", + "\n", + "# After training\n", + "print(\"predict (after training)\", \"4 ,\", forward(4))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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 +} diff --git a/notebooks/03_auto_gradient.ipynb b/notebooks/03_auto_gradient.ipynb new file mode 100644 index 0000000..4d2c1cd --- /dev/null +++ b/notebooks/03_auto_gradient.ipynb @@ -0,0 +1,149 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4.1\n" + ] + } + ], + "source": [ + "import torch\n", + "import torchvision\n", + "from torch.autograd import Variable\n", + "\n", + "print(torch.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "x_data = [1.0, 2.0, 3.0]\n", + "y_data = [2.0, 4.0, 6.0]\n", + "\n", + "w = Variable(torch.Tensor([1.0]), requires_grad=True) # Any random value" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predict (before training) : 4 , tensor(4.)\n" + ] + } + ], + "source": [ + "# our model forward pass\n", + "\n", + "def forward(x):\n", + " return x * w\n", + "\n", + "# Loss function\n", + "\n", + "def loss(x, y):\n", + " y_pred = forward(x)\n", + " return (y_pred - y) ** 2\n", + "\n", + "# Before training\n", + "print(\"predict (before training) : \", 4,\",\", forward(4).data[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "progress: 0 tensor(7.3159)\n", + "progress: 1 tensor(3.9988)\n", + "progress: 2 tensor(2.1857)\n", + "progress: 3 tensor(1.1946)\n", + "progress: 4 tensor(0.6530)\n", + "progress: 5 tensor(0.3569)\n", + "progress: 6 tensor(0.1951)\n", + "progress: 7 tensor(0.1066)\n", + "progress: 8 tensor(0.0583)\n", + "progress: 9 tensor(0.0319)\n" + ] + } + ], + "source": [ + "# Training loop\n", + "for epoch in range(10):\n", + " for x_val, y_val in zip(x_data, y_data):\n", + " l = loss(x_val, y_val)\n", + " l.backward()\n", + " #print(\"\\tgrad: \", x_val, y_val, w.grad.data[0])\n", + " w.data = w.data - 0.01 * w.grad.data\n", + "\n", + " # Manually zero the gradients after updating weights\n", + " w.grad.data.zero_()\n", + "\n", + " print(\"progress:\", epoch, l.data[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predict (after training) 4 , tensor(7.8049)\n" + ] + } + ], + "source": [ + "# After training\n", + "print(\"predict (after training)\", 4, \",\",forward(4).data[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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 +} diff --git a/notebooks/04_linear_regression.ipynb b/notebooks/04_linear_regression.ipynb new file mode 100644 index 0000000..0962ed9 --- /dev/null +++ b/notebooks/04_linear_regression.ipynb @@ -0,0 +1,148 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4.1\n" + ] + } + ], + "source": [ + "import torch\n", + "from torch.autograd import Variable\n", + "\n", + "print(torch.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "x_data = Variable(torch.Tensor([[1.0], [2.0], [3.0]]))\n", + "y_data = Variable(torch.Tensor([[2.0], [4.0], [6.0]]))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class Model(torch.nn.Module):\n", + "\n", + " def __init__(self):\n", + " \"\"\"\n", + " In the constructor we instantiate two nn.Linear module\n", + " \"\"\"\n", + " super(Model, self).__init__()\n", + " self.linear = torch.nn.Linear(1, 1) # One in and one out\n", + "\n", + " def forward(self, x):\n", + " \"\"\"\n", + " In the forward function we accept a Variable of input data and we must return\n", + " a Variable of output data. We can use Modules defined in the constructor as\n", + " well as arbitrary operators on Variables.\n", + " \"\"\"\n", + " y_pred = self.linear(x)\n", + " return y_pred" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# our model\n", + "model = Model()\n", + "\n", + "\n", + "# Construct our loss function and an Optimizer. The call to model.parameters()\n", + "# in the SGD constructor will contain the learnable parameters of the two\n", + "# nn.Linear modules which are members of the model.\n", + "criterion = torch.nn.MSELoss(reduction='sum')\n", + "optimizer = torch.optim.SGD(model.parameters(), lr=0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Final Loss : 0.0004843869246542454\n" + ] + } + ], + "source": [ + "# Training loop\n", + "for epoch in range(500):\n", + " # Forward pass: Compute predicted y by passing x to the model\n", + " y_pred = model(x_data)\n", + "\n", + " # Compute and print loss\n", + " loss = criterion(y_pred, y_data)\n", + " #print(epoch, loss.item())\n", + "\n", + " # Zero gradients, perform a backward pass, and update the weights.\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + "print(\"Final Loss : \",loss.item())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predict (after training) 4 : tensor(7.9747)\n" + ] + } + ], + "source": [ + "# After training\n", + "hour_var = Variable(torch.Tensor([[4.0]]))\n", + "y_pred = model(hour_var)\n", + "print(\"predict (after training)\", 4,\":\", model(hour_var).data[0][0])" + ] + } + ], + "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 +} diff --git a/notebooks/05_logistic_regression.ipynb b/notebooks/05_logistic_regression.ipynb new file mode 100644 index 0000000..a8d5ef8 --- /dev/null +++ b/notebooks/05_logistic_regression.ipynb @@ -0,0 +1,151 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4.1\n" + ] + } + ], + "source": [ + "import torch\n", + "from torch.autograd import Variable\n", + "import torch.nn.functional as F\n", + "from torch import sigmoid \n", + "\n", + "print(torch.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "x_data = Variable(torch.Tensor([[1.0], [2.0], [3.0], [4.0]]))\n", + "y_data = Variable(torch.Tensor([[0.], [0.], [1.], [1.]]))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class Model(torch.nn.Module):\n", + "\n", + " def __init__(self):\n", + " \"\"\"\n", + " In the constructor we instantiate nn.Linear module\n", + " \"\"\"\n", + " super(Model, self).__init__()\n", + " self.linear = torch.nn.Linear(1, 1) # One in and one out\n", + "\n", + " def forward(self, x):\n", + " \"\"\"\n", + " In the forward function we accept a Variable of input data and we must return\n", + " a Variable of output data.\n", + " \"\"\"\n", + " y_pred = sigmoid(self.linear(x))\n", + " return y_pred" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# our model\n", + "model = Model()\n", + "\n", + "\n", + "# Construct our loss function and an Optimizer. The call to model.parameters()\n", + "# in the SGD constructor will contain the learnable parameters of the two\n", + "# nn.Linear modules which are members of the model.\n", + "criterion = torch.nn.BCELoss(reduction='elementwise_mean')\n", + "optimizer = torch.optim.SGD(model.parameters(), lr=0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Final loss : 0.46247029304504395\n" + ] + } + ], + "source": [ + "# Training loop\n", + "for epoch in range(1000):\n", + " # Forward pass: Compute predicted y by passing x to the model\n", + " y_pred = model(x_data)\n", + "\n", + " # Compute and print loss\n", + " loss = criterion(y_pred, y_data)\n", + " #print(epoch, loss.item())\n", + "\n", + " # Zero gradients, perform a backward pass, and update the weights.\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + "print('Final loss : ',loss.item())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predict 1 hour 1.0 : False\n", + "predict 7 hours 7.0 : True\n" + ] + } + ], + "source": [ + "# After training\n", + "hour_var = Variable(torch.Tensor([[1.0]]))\n", + "print(\"predict 1 hour \", 1.0,\":\", model(hour_var).item() > 0.5)\n", + "hour_var = Variable(torch.Tensor([[7.0]]))\n", + "print(\"predict 7 hours\", 7.0,\":\", model(hour_var).item() > 0.5)" + ] + } + ], + "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 +} diff --git a/notebooks/06_diabets_logistic.ipynb b/notebooks/06_diabets_logistic.ipynb new file mode 100644 index 0000000..37823ef --- /dev/null +++ b/notebooks/06_diabets_logistic.ipynb @@ -0,0 +1,293 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4.1\n" + ] + } + ], + "source": [ + "import torch\n", + "from torch.autograd import Variable\n", + "import numpy as np\n", + "\n", + "print(torch.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012345678
0-0.2941180.4874370.180328-0.2929290.0000000.001490-0.531170-0.0333330
1-0.882353-0.1457290.081967-0.4141410.000000-0.207153-0.766866-0.6666671
2-0.0588240.8391960.0491800.0000000.000000-0.305514-0.492741-0.6333330
3-0.882353-0.1055280.081967-0.535354-0.777778-0.162444-0.9239970.0000001
40.0000000.376884-0.344262-0.292929-0.6028370.2846500.887276-0.6000000
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4 5 6 \\\n", + "0 -0.294118 0.487437 0.180328 -0.292929 0.000000 0.001490 -0.531170 \n", + "1 -0.882353 -0.145729 0.081967 -0.414141 0.000000 -0.207153 -0.766866 \n", + "2 -0.058824 0.839196 0.049180 0.000000 0.000000 -0.305514 -0.492741 \n", + "3 -0.882353 -0.105528 0.081967 -0.535354 -0.777778 -0.162444 -0.923997 \n", + "4 0.000000 0.376884 -0.344262 -0.292929 -0.602837 0.284650 0.887276 \n", + "\n", + " 7 8 \n", + "0 -0.033333 0 \n", + "1 -0.666667 1 \n", + "2 -0.633333 0 \n", + "3 0.000000 1 \n", + "4 -0.600000 0 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Shown with normalization\n", + "\n", + "import pandas as pd\n", + "df = pd.read_csv('./data/diabetes.csv.gz',header=None)\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "xy = np.loadtxt('../data/diabetes.csv.gz', delimiter=',', dtype=np.float32)\n", + "x_data = Variable(torch.from_numpy(xy[:, 0:-1]))\n", + "y_data = Variable(torch.from_numpy(xy[:, [-1]]))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([759, 8])\n", + "torch.Size([759, 1])\n" + ] + } + ], + "source": [ + "print(x_data.data.shape)\n", + "print(y_data.data.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class Model(torch.nn.Module):\n", + "\n", + " def __init__(self):\n", + " \"\"\"\n", + " In the constructor we instantiate two nn.Linear module\n", + " \"\"\"\n", + " super(Model, self).__init__()\n", + " self.l1 = torch.nn.Linear(8, 6)\n", + " self.l2 = torch.nn.Linear(6, 4)\n", + " self.l3 = torch.nn.Linear(4, 1)\n", + "\n", + " self.sigmoid = torch.nn.Sigmoid()\n", + "\n", + " def forward(self, x):\n", + " \"\"\"\n", + " In the forward function we accept a Variable of input data and we must return\n", + " a Variable of output data. We can use Modules defined in the constructor as\n", + " well as arbitrary operators on Variables.\n", + " \"\"\"\n", + " out1 = self.sigmoid(self.l1(x))\n", + " out2 = self.sigmoid(self.l2(out1))\n", + " y_pred = self.sigmoid(self.l3(out2))\n", + " return y_pred" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# our model\n", + "model = Model()\n", + "\n", + "\n", + "# Construct our loss function and an Optimizer. The call to model.parameters()\n", + "# in the SGD constructor will contain the learnable parameters of the two\n", + "# nn.Linear modules which are members of the model.\n", + "criterion = torch.nn.BCELoss(reduction='elementwise_mean')\n", + "optimizer = torch.optim.SGD(model.parameters(), lr=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Final Loss : 0.6451954245567322\n" + ] + } + ], + "source": [ + "# Training loop\n", + "for epoch in range(100):\n", + " # Forward pass: Compute predicted y by passing x to the model\n", + " y_pred = model(x_data)\n", + "\n", + " # Compute and print loss\n", + " loss = criterion(y_pred, y_data)\n", + " #print(epoch, loss.item())\n", + "\n", + " # Zero gradients, perform a backward pass, and update the weights.\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + "print('Final Loss : ',loss.item()) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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 +}