diff --git a/ClassificationWithLinearRegression.ipynb b/ClassificationWithLinearRegression.ipynb new file mode 100644 index 0000000..e0e21e9 --- /dev/null +++ b/ClassificationWithLinearRegression.ipynb @@ -0,0 +1,263 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Classification with linear regression" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.animation as animation\n", + "from scipy import stats \n", + "\n", + "from sklearn.datasets.samples_generator import make_blobs" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "X, y = make_blobs(n_samples=100, centers= np.array([[-1],[1]]), n_features=1, shuffle=True, random_state=2017)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X,y)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LinearRegression" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "lr = LinearRegression().fit(X,y)\n", + "xgrid = np.linspace(-3.5,3.5, 1000)\n", + "Xgrid = xgrid.reshape(-1,1)\n", + "Y = y.reshape(-1,1)\n", + "yp = lr.predict(X)\n", + "ypgrid = lr.predict(Xgrid)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "x = X.flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(X,y,'o', alpha=0.4, ms=5)\n", + "plt.plot(xgrid, ypgrid)\n", + "plt.plot(x, yp, 's', alpha=.5, ms=5)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def makeyaprob(y):\n", + " if y >=1.0:\n", + " return 1.0\n", + " elif y <= 0.0:\n", + " return 0.0\n", + " else:\n", + " return y\n", + "vector_makeyaprob = np.vectorize(makeyaprob)\n", + "predict_proba = lambda lr, X: vector_makeyaprob(lr.predict(X))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "ypfilt = vector_makeyaprob(ypgrid)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# ypfilt = np.zeros(xgrid.shape[0])\n", + "# def predicted_proba(x)\n", + "# for i,x in enumerate(xgrid):\n", + "# if yp[i] >= 1.0:\n", + "# ypfilt[i] = 1.0\n", + "# elif yp[i] <= 0.0:\n", + "# ypfilt[i] = 0.0\n", + "# else:\n", + "# ypfilt[i] = yp[i]" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(X,y,'o')\n", + "plt.plot(xgrid, ypfilt)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "ypred = 1*(predict_proba(lr, X) >= 0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import accuracy_score" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.95" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "accuracy_score(y, ypred)" + ] + } + ], + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ClassificationWithLogisticRegression.ipynb b/ClassificationWithLogisticRegression.ipynb new file mode 100644 index 0000000..7c5017f --- /dev/null +++ b/ClassificationWithLogisticRegression.ipynb @@ -0,0 +1,893 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Classification with Logistic regression" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.animation as animation\n", + "from scipy import stats \n", + "\n", + "from sklearn.datasets.samples_generator import make_blobs" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "X, y = make_blobs(n_samples=100, centers= np.array([[-1],[1]]), n_features=1, shuffle=True, random_state=2017)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X,y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using sklearn" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "xgrid = np.linspace(-3.5,3.5, 1000)\n", + "Xgrid = xgrid.reshape(-1,1)\n", + "Y = y.reshape(-1,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "//anaconda/envs/py3l/lib/python3.6/site-packages/sklearn/linear_model/logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n", + " FutureWarning)\n" + ] + } + ], + "source": [ + "logr = LogisticRegression(C=10000)\n", + "logr.fit(X,y)\n", + "yp2 = logr.predict(Xgrid)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(X,y,'o')\n", + "plt.plot(xgrid, yp2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[9.99991656e-01, 8.34395170e-06],\n", + " [9.99991460e-01, 8.54008992e-06],\n", + " [9.99991259e-01, 8.74083864e-06],\n", + " ...,\n", + " [1.04266602e-05, 9.99989573e-01],\n", + " [1.01871940e-05, 9.99989813e-01],\n", + " [9.95322753e-06, 9.99990047e-01]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "logr.predict_proba(Xgrid)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "probs = logr.predict_proba(Xgrid)[:,1]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(X,y,'o')\n", + "plt.plot(xgrid, probs)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([[3.31593843]]), array([-0.08818078]))" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "logr.coef_, logr.intercept_" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import accuracy_score" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.93" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "accuracy_score(y, logr.predict(X))" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.93" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ypred = 1*(logr.predict_proba(X)[:,1] >= 0.5)\n", + "accuracy_score(y, ypred)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using pytorch and sigmoids" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import torch" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# from https://www.stefanfiott.com/machine-learning/tensors-and-gradients-in-pytorch/\n", + "def tensor_properties(t, show_value=True):\n", + " print('Tensor properties:')\n", + " props = [('rank', t.dim()),\n", + " ('shape', t.size()),\n", + " ('data type', t.dtype),\n", + " ('tensor type', t.type())]\n", + " for s,v in props:\n", + " print('\\t{0:12}: {1}'.format(s,v))\n", + " if show_value:\n", + " #print('{0:12}: {1}'.format('value',t))\n", + " print(\"Value:\")\n", + " print(t)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "X_data = torch.from_numpy(X).float()\n", + "Y_data = torch.from_numpy(Y).float()\n", + "y_data = torch.from_numpy(y).float()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tensor properties:\n", + "\trank : 2\n", + "\tshape : torch.Size([100, 1])\n", + "\tdata type : torch.float32\n", + "\ttensor type : torch.FloatTensor\n", + "Value:\n", + "tensor([[1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.]])\n" + ] + } + ], + "source": [ + "tensor_properties(Y_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "class Model0(torch.nn.Module):\n", + "\n", + " def __init__(self):\n", + " \"\"\"\n", + " In the constructor we instantiate nn.Linear module\n", + " \"\"\"\n", + " super(Model0, self).__init__()\n", + " self.linear = torch.nn.Linear(1, 1) # One in and two out\n", + " self.sigmoid = torch.nn.Sigmoid()\n", + "\n", + " def forward(self, x):\n", + " linears = self.linear(x)\n", + " probs = self.sigmoid(linears)\n", + " return probs" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "model = Model0()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "//anaconda/envs/py3l/lib/python3.6/site-packages/torch/nn/functional.py:2016: UserWarning: Using a target size (torch.Size([100])) that is different to the input size (torch.Size([100, 1])) is deprecated. Please ensure they have the same size.\n", + " \"Please ensure they have the same size.\".format(target.size(), input.size()))\n" + ] + } + ], + "source": [ + "# Construct our loss function and an Optimizer. The call to model.parameters()\n", + "# in the SGD constructor will contain the learnable parameters of the \n", + "# nn.Linear modules which are members of the model.\n", + "criterion = torch.nn.BCELoss()\n", + "optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=0.01)\n", + "\n", + "# Training loop\n", + "accum = []\n", + "for epoch in range(10000):\n", + " \n", + " # Forward pass: Compute predicted y by passing x to the modela\n", + " \n", + " optimizer.zero_grad()\n", + " \n", + " prob_pred = model.forward(X_data)\n", + "\n", + " # Compute and print loss\n", + " loss = criterion(prob_pred, y_data)\n", + " accum.append(loss.item())\n", + " #print(loss.item())\n", + "\n", + " # Zero gradients, perform a backward pass, and update the weights.\n", + " \n", + " loss.backward()\n", + " optimizer.step()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(accum)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('linear.weight', Parameter containing:\n", + " tensor([[2.4066]], requires_grad=True)),\n", + " ('linear.bias', Parameter containing:\n", + " tensor([0.0057], requires_grad=True))]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(model.named_parameters())" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "Xgrid_data = torch.from_numpy(Xgrid).float()\n", + "probs_sigmoid = model.forward(Xgrid_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(X,y,'o')\n", + "plt.plot(xgrid, probs_sigmoid.detach().numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "probs_sigmoid_X = model.forward(X_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.95" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ypred = 1*(probs_sigmoid_X.detach().numpy().flatten() >= 0.5)\n", + "accuracy_score(y, ypred)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using pytorch and softmax" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "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, 2) # One in and two out\n", + " self.lsm = torch.nn.LogSoftmax()\n", + "\n", + " def forward(self, x):\n", + " linears = self.linear(x)\n", + " logprobs = self.lsm(linears)\n", + " return logprobs" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "model = Model()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "//anaconda/envs/py3l/lib/python3.6/site-packages/ipykernel_launcher.py:13: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n", + " del sys.path[0]\n" + ] + } + ], + "source": [ + "# Construct our loss function and an Optimizer. The call to model.parameters()\n", + "# in the SGD constructor will contain the learnable parameters of the \n", + "# nn.Linear modules which are members of the model.\n", + "criterion = torch.nn.NLLLoss()\n", + "optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=0.01)\n", + "\n", + "# Training loop\n", + "accum = []\n", + "for epoch in range(10000):\n", + " \n", + " # Forward pass: Compute predicted y by passing x to the modela\n", + " \n", + " optimizer.zero_grad()\n", + " \n", + " prob_pred = model.forward(X_data)\n", + "\n", + " # Compute and print loss\n", + " loss = criterion(prob_pred, y_data.long())\n", + " accum.append(loss.item())\n", + " #print(loss.item())\n", + "\n", + " # Zero gradients, perform a backward pass, and update the weights.\n", + " \n", + " loss.backward()\n", + " optimizer.step()" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(accum)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('linear.weight', Parameter containing:\n", + " tensor([[-1.4811],\n", + " [ 1.2287]], requires_grad=True)),\n", + " ('linear.bias', Parameter containing:\n", + " tensor([-0.0860, -0.1038], requires_grad=True))]" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(model.named_parameters())" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "//anaconda/envs/py3l/lib/python3.6/site-packages/ipykernel_launcher.py:13: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n", + " del sys.path[0]\n" + ] + }, + { + "data": { + "text/plain": [ + "torch.Size([1000, 2])" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# After training\n", + "logprobs_smax = model.forward(Xgrid_data)\n", + "logprobs_smax.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(X,y,'o')\n", + "plt.plot(xgrid, np.exp(logprobs_smax.detach().numpy()[:,1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "//anaconda/envs/py3l/lib/python3.6/site-packages/ipykernel_launcher.py:13: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n", + " del sys.path[0]\n" + ] + }, + { + "data": { + "text/plain": [ + "0.94" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "logprobs_smax_X = model.forward(X_data)\n", + "ypred = 1*(np.exp(logprobs_smax_X.detach().numpy()[:,1]) >= 0.5)\n", + "accuracy_score(y, ypred)" + ] + } + ], + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/images/1dclass.png b/images/1dclass.png new file mode 100644 index 0000000..666af59 Binary files /dev/null and b/images/1dclass.png differ diff --git a/images/1dclasslinear.png b/images/1dclasslinear.png new file mode 100644 index 0000000..5cd4da0 Binary files /dev/null and b/images/1dclasslinear.png differ diff --git a/images/1dclasslinearprobs.png b/images/1dclasslinearprobs.png new file mode 100644 index 0000000..735a1fc Binary files /dev/null and b/images/1dclasslinearprobs.png differ diff --git a/images/1dclasslogisticprobs.png b/images/1dclasslogisticprobs.png new file mode 100644 index 0000000..c5057d4 Binary files /dev/null and b/images/1dclasslogisticprobs.png differ diff --git a/images/1dgd-bigstep.mp4 b/images/1dgd-bigstep.mp4 new file mode 100644 index 0000000..f0cd81e Binary files /dev/null and b/images/1dgd-bigstep.mp4 differ diff --git a/images/1dgd-smallstep.mp4 b/images/1dgd-smallstep.mp4 new file mode 100644 index 0000000..e06547c Binary files /dev/null and b/images/1dgd-smallstep.mp4 differ diff --git a/images/1dgd.mp4 b/images/1dgd.mp4 new file mode 100644 index 0000000..f8dd8bf Binary files /dev/null and b/images/1dgd.mp4 differ diff --git a/images/animsgd.gif b/images/animsgd.gif new file mode 100644 index 0000000..8cb6651 Binary files /dev/null and b/images/animsgd.gif differ diff --git a/images/bps1.png b/images/bps1.png new file mode 100644 index 0000000..0123cc0 Binary files /dev/null and b/images/bps1.png differ diff --git a/images/bps2.png b/images/bps2.png new file mode 100644 index 0000000..f2447a6 Binary files /dev/null and b/images/bps2.png differ diff --git a/images/bps3.png b/images/bps3.png new file mode 100644 index 0000000..9d72bba Binary files /dev/null and b/images/bps3.png differ diff --git a/images/bps4.png b/images/bps4.png new file mode 100644 index 0000000..c39980f Binary files /dev/null and b/images/bps4.png differ diff --git a/images/bps5.png b/images/bps5.png new file mode 100644 index 0000000..ccb90b4 Binary files /dev/null and b/images/bps5.png differ diff --git a/images/bps6.png b/images/bps6.png new file mode 100644 index 0000000..8ebbcc1 Binary files /dev/null and b/images/bps6.png differ diff --git a/images/celoss.png b/images/celoss.png new file mode 100644 index 0000000..b90d440 Binary files /dev/null and b/images/celoss.png differ diff --git a/images/dropout.png b/images/dropout.png new file mode 100644 index 0000000..4634cc2 Binary files /dev/null and b/images/dropout.png differ diff --git a/images/earlystop.png b/images/earlystop.png new file mode 100644 index 0000000..e49e4d6 Binary files /dev/null and b/images/earlystop.png differ diff --git a/images/flbl.png b/images/flbl.png new file mode 100644 index 0000000..8c191fa Binary files /dev/null and b/images/flbl.png differ diff --git a/images/gdline.mp4 b/images/gdline.mp4 new file mode 100644 index 0000000..cbc982f Binary files /dev/null and b/images/gdline.mp4 differ diff --git a/images/layercake.png b/images/layercake.png new file mode 100644 index 0000000..cb86c2e Binary files /dev/null and b/images/layercake.png differ diff --git a/images/layerl.png b/images/layerl.png new file mode 100644 index 0000000..a297fd7 Binary files /dev/null and b/images/layerl.png differ diff --git a/images/layershororig.png b/images/layershororig.png new file mode 100644 index 0000000..0cbf52c Binary files /dev/null and b/images/layershororig.png differ diff --git a/images/layershorsm.png b/images/layershorsm.png new file mode 100644 index 0000000..291df38 Binary files /dev/null and b/images/layershorsm.png differ diff --git a/images/layershorstd.png b/images/layershorstd.png new file mode 100644 index 0000000..6d975cd Binary files /dev/null and b/images/layershorstd.png differ diff --git a/images/linreg.png b/images/linreg.png new file mode 100644 index 0000000..e91d490 Binary files /dev/null and b/images/linreg.png differ diff --git a/images/linregmle.png b/images/linregmle.png new file mode 100644 index 0000000..39ec2b9 Binary files /dev/null and b/images/linregmle.png differ diff --git a/images/lossandout.png b/images/lossandout.png new file mode 100644 index 0000000..2edfec6 Binary files /dev/null and b/images/lossandout.png differ diff --git a/images/mlmin.png b/images/mlmin.png new file mode 100644 index 0000000..017c762 Binary files /dev/null and b/images/mlmin.png differ diff --git a/images/mseloss.png b/images/mseloss.png new file mode 100644 index 0000000..ae7ba2c Binary files /dev/null and b/images/mseloss.png differ diff --git a/images/newsgd1.png b/images/newsgd1.png new file mode 100644 index 0000000..d82e273 Binary files /dev/null and b/images/newsgd1.png differ diff --git a/images/nnreg.png b/images/nnreg.png new file mode 100644 index 0000000..f16f4c6 Binary files /dev/null and b/images/nnreg.png differ diff --git a/images/noreg.png b/images/noreg.png new file mode 100644 index 0000000..b31e281 Binary files /dev/null and b/images/noreg.png differ diff --git a/images/onelinesplit.png b/images/onelinesplit.png new file mode 100644 index 0000000..151d4f7 Binary files /dev/null and b/images/onelinesplit.png differ diff --git a/images/optimcalc_4_0.png b/images/optimcalc_4_0.png new file mode 100644 index 0000000..5ed97ca Binary files /dev/null and b/images/optimcalc_4_0.png differ diff --git a/images/sigmoid.png b/images/sigmoid.png new file mode 100644 index 0000000..1a40139 Binary files /dev/null and b/images/sigmoid.png differ diff --git a/keras_dropout.py b/keras_dropout.py new file mode 100644 index 0000000..801df39 --- /dev/null +++ b/keras_dropout.py @@ -0,0 +1,49 @@ +# from wandb classes +import numpy +from keras.datasets import mnist +from keras.models import Sequential +from keras.layers import Dense, Flatten, Dropout +from keras.utils import np_utils +import json + +from wandb.keras import WandbCallback +import wandb + +run = wandb.init() +config = run.config +config.optimizer = "adam" +config.epochs = 50 +config.dropout = 0.4 +config.hidden_nodes = 100 + +# load data +(X_train, y_train), (X_test, y_test) = mnist.load_data() +img_width = X_train.shape[1] +img_height = X_train.shape[2] + +X_train = X_train.astype('float32') +X_train /= 255. +X_test = X_test.astype('float32') +X_test /= 255. + +# one hot encode outputs +y_train = np_utils.to_categorical(y_train) +y_test = np_utils.to_categorical(y_test) +labels = range(10) + +num_classes = y_train.shape[1] + +# create model +model=Sequential() +model.add(Flatten(input_shape=(img_width,img_height))) +model.add(Dropout(config.dropout)) +model.add(Dense(config.hidden_nodes, activation='relu')) +model.add(Dropout(config.dropout)) +model.add(Dense(num_classes, activation='softmax')) +model.compile(loss='categorical_crossentropy', optimizer=config.optimizer, + metrics=['accuracy']) + + +# Fit the model +model.fit(X_train, y_train, validation_data=(X_test, y_test), + epochs=config.epochs, callbacks=[WandbCallback(data_type="image", labels=labels)]) diff --git a/lecture.md b/lecture.md new file mode 100644 index 0000000..60d1f85 --- /dev/null +++ b/lecture.md @@ -0,0 +1,593 @@ +footer:![30%, filtered](/Users/rahul/Downloads/Logo_Univ_AI_Blue_Rectangle.png) +autoscale: true + +![inline](/Users/rahul/Downloads/Logo_Univ_AI_Blue_Rectangle.png) + +--- + +#[fit] Ai 1 + +--- + +#[fit] Losses, +# and +#[fit] Learning + +--- + +##[fit] Minimize +##[fit] Cost + +--- + +![](../movies/nn21.mp4) + +--- + + + +## Regression: continuous prediction + +- how many dollars will you spend? +- what is your creditworthiness +- how many people will vote for Bernie t days before election +- use to predict probabilities for classification +- causal modeling in econometrics + +![fit, right](images/linreg.png) + +--- + + +Linear Regression + +$$\hat{y} = f_\theta (x) =\theta^T x$$ + +Cost Function: + +$$R(\theta) = \frac{1}{2} \sum_{i=1}^m (f_\theta (x^{(i)}-y^{(i)})^2$$ + +###[fit] MINIMIZE SQUARED ERROR. Its Convex! + +--- + +![](../movies/nn24.mp4) + +--- + +## Gradient ascent (descent) + +basically go opposite the direction of the derivative. + +Consider the objective function: $$ J(x) = x^2-6x+5 $$ + +```python +gradient = fprime(old_x) +move = gradient * step +current_x = old_x - move +``` + +![right, fit](images/optimcalc_4_0.png) + + +--- + +## good step size + +![inline](images/1dgd.mp4) + +--- + +## too big step size + +![inline](images/1dgd-bigstep.mp4) + +--- + +## too small step size + +![inline](images/1dgd-smallstep.mp4) + +--- + +## Gradient Descent + +$$\theta := \theta - \eta \nabla_{\theta} R(\theta) = \theta -\eta \sum_{i=1}^m \nabla R_i(\theta)$$ + +where $$\eta$$ is the learning rate. + +ENTIRE DATASET NEEDED + +```python +for i in range(n_epochs): + params_grad = evaluate_gradient(loss_function, data, params) + params = params - learning_rate * params_grad` +``` + +--- + +## Linear Regression: Gradient Descent + +$$\theta_j := \theta_j + \alpha \sum_{i=1}^m (y^{(i)}-f_\theta (x^{(i)})) x_j^{(i)}$$ + +![right](images/gdline.mp4) + + +--- + +## Stochastic Gradient Descent + +$$\theta := \theta - \alpha \nabla_{\theta} R_i(\theta)$$ + + +ONE POINT AT A TIME + +For Linear Regression: + +$$\theta_j := \theta_j + \alpha (y^{(i)}-f_\theta (x^{(i)})) x_j^{(i)}$$ + +```python +for i in range(nb_epochs): + np.random.shuffle(data) + for example in data: + params_grad = evaluate_gradient(loss_function, example, params) + params = params - learning_rate * params_grad +``` + +--- + +Mini-Batch SGD (the most used) + +$$\theta := \theta - \eta \nabla_{\theta} J(\theta; x^{(i:i+n)}; y^{(i:i+n)})$$ + +```python +for i in range(mb_epochs): + np.random.shuffle(data) + for batch in get_batches(data, batch_size=50): + params_grad = evaluate_gradient(loss_function, batch, params) + params = params - learning_rate * params_grad +``` + +--- +[.autoscale: true] + +## Mini-Batch: do some at a time + +- the risk surface changes at each gradient calculation +- thus things are noisy +- cumulated risk is smoother, can be used to compare to SGD +- epochs are now the number of times you revisit the full dataset +- shuffle in-between to provide even more stochasticity + +--- + +![inline](images/flbl.png) + +--- + +![fit, inline](images/animsgd.gif) + +--- + +#[fit] Ok, so where did this +#[fit] Mean Squared Loss +#[fit] come from? + +--- + +## Gaussian Distribution assumption ! + +![inline](images/linregmle.png) + +--- + +## Gaussian Distribution assumption + +$$\renewcommand{\v}[1]{\mathbf #1}$$ +Each $$y_i$$ is gaussian distributed with mean $$\mathbf{w}\cdot\mathbf{x}_i$$ (the y predicted by the regression line) and variance $$\sigma^2$$: + + +$$ +\renewcommand{\v}[1]{\mathbf #1} +y_i \sim N(\v{w}\cdot\v{x_i}, \sigma^2) .$$ + +$$N(\mu, \sigma^2) = \frac{1}{\sigma\sqrt{2\pi}} e^{-(y - \mu)^2 / 2\sigma^2},$$ + + +--- + +We can then write the likelihood: + +$$ +\renewcommand{\v}[1]{\mathbf #1} +\cal{L} = p(\v{y} | \v{x}, \v{w}, \sigma) = \prod_i p(\v{y}_i | \v{x}_i, \v{w}, \sigma)$$ + + +$$\renewcommand{\v}[1]{\mathbf #1} +\cal{L} = (2\pi\sigma^2)^{(-n/2)} e^{\frac{-1}{2\sigma^2} \sum_i (y_i - \v{w}\cdot\v{x}_i)^2} .$$ + +The log likelihood $$\ell$$ then is given by: + +$$\renewcommand{\v}[1]{\mathbf #1} +\ell = \frac{-n}{2} log(2\pi\sigma^2) - \frac{1}{2\sigma^2} \sum_i (y_i - \v{w}\cdot\v{x}_i)^2 .$$ + +--- + +## Maximize $$\ell$$ ? + +## No. Minimize $$-\ell$$ using Gradient Descent! + +If all you care for are the parameters $$w$$, then: + +##Minimize Loss or Cost: + +$$Loss = \frac{1}{N} \sum_i (y_i - \v{w}\cdot\v{x}_i)^2 .$$ + +--- + +## Where's the neural network? + +Replace $$\v{w}\cdot\v{x}_i)^2$$ with $$NN(\v{w}\cdot\v{x}_i)^2)$$. + +So: + +$$Loss = \frac{1}{N} \sum_i (y_i - NN\,(\v{w}\cdot\v{x}_i)^2) .$$ + +--- + +## The Loss is now NOT CONVEX! + +![inline](images/mlmin.png) + +--- + +#[fit]CLASSIFICATION + +- will a customer churn? +- is this a check? For how much? +- a man or a woman? +- will this customer buy? +- do you have cancer? +- is this spam? +- whose picture is this? +- what is this text about?[^j] + +![fit, left](images/onelinesplit.png) + +[^j]:image from code in http://bit.ly/1Azg29G + +--- + +## 1-D classification problem + +![inline](images/1dclass.png) + +--- + +## 1-D Using Linear regression + +![inline](images/1dclasslinear.png)![inline](images/1dclasslinearprobs.png) + +--- + +##[fit] MLE for Logistic Regression + +- example of a Generalized Linear Model (GLM) +- "Squeeze" linear regression through a **Sigmoid** function +- this bounds the output to be a probability + +--- + +## Sigmoid function + +This function is plotted below: + +```python +h = lambda z: 1./(1+np.exp(-z)) +zs=np.arange(-5,5,0.1) +plt.plot(zs, h(zs), alpha=0.5); +``` + +![right, fit](images/sigmoid.png) + +Identify: $$\renewcommand{\v}[1]{\mathbf #1} z = \v{w}\cdot\v{x}$$ and $$ \renewcommand{\v}[1]{\mathbf #1} h(\v{w}\cdot\v{x})$$ with the probability that the sample is a '1' ($$y=1$$). + +--- + +Then, the conditional probabilities of $$y=1$$ or $$y=0$$ given a particular sample's features $$\renewcommand{\v}[1]{\mathbf #1} \v{x}$$ are: + +$$\begin{eqnarray} +\renewcommand{\v}[1]{\mathbf #1} +P(y=1 | \v{x}) &=& h(\v{w}\cdot\v{x}) \\ +P(y=0 | \v{x}) &=& 1 - h(\v{w}\cdot\v{x}). +\end{eqnarray}$$ + +These two can be written together as + +$$\renewcommand{\v}[1]{\mathbf #1} P(y|\v{x}, \v{w}) = h(\v{w}\cdot\v{x})^y \left(1 - h(\v{w}\cdot\v{x}) \right)^{(1-y)} $$ + +BERNOULLI!! + +--- + +Multiplying over the samples we get: + +$$\renewcommand{\v}[1]{\mathbf #1} P(y|\v{x},\v{w}) = P(\{y_i\} | \{\v{x}_i\}, \v{w}) = \prod_{y_i \in \cal{D}} P(y_i|\v{x_i}, \v{w}) = \prod_{y_i \in \cal{D}} h(\v{w}\cdot\v{x_i})^{y_i} \left(1 - h(\v{w}\cdot\v{x_i}) \right)^{(1-y_i)}$$ + +Indeed its important to realize that a particular sample can be thought of as a draw from some "true" probability distribution. + + **maximum likelihood** estimation maximises the **likelihood of the sample y**, or alternately the log-likelihood, + +$$\renewcommand{\v}[1]{\mathbf #1} {\cal L} = P(y \mid \v{x},\v{w}).$$ OR $$\renewcommand{\v}[1]{\mathbf #1} \ell = log(P(y \mid \v{x},\v{w}))$$ + +--- + +Thus + +$$\renewcommand{\v}[1]{\mathbf #1} \begin{eqnarray} +\ell &=& log\left(\prod_{y_i \in \cal{D}} h(\v{w}\cdot\v{x_i})^{y_i} \left(1 - h(\v{w}\cdot\v{x_i}) \right)^{(1-y_i)}\right)\\ + &=& \sum_{y_i \in \cal{D}} log\left(h(\v{w}\cdot\v{x_i})^{y_i} \left(1 - h(\v{w}\cdot\v{x_i}) \right)^{(1-y_i)}\right)\\ + &=& \sum_{y_i \in \cal{D}} log\,h(\v{w}\cdot\v{x_i})^{y_i} + log\,\left(1 - h(\v{w}\cdot\v{x_i}) \right)^{(1-y_i)}\\ + &=& \sum_{y_i \in \cal{D}} \left ( y_i log(h(\v{w}\cdot\v{x})) + ( 1 - y_i) log(1 - h(\v{w}\cdot\v{x})) \right ) +\end{eqnarray}$$ + +--- +[.autoscale: true] + +## Logistic Regression: NLL + +The negative of this log likelihood (NLL), also called *cross-entropy*. + +$$\renewcommand{\v}[1]{\mathbf #1} NLL = - \sum_{y_i \in \cal{D}} \left ( y_i log(h(\v{w}\cdot\v{x})) + ( 1 - y_i) log(1 - h(\v{w}\cdot\v{x})) \right )$$ + +This loss is convex. Many ways can be chosen to minimize it, but we can just use gradient descent :-) + +--- + +## 1-D Using Logistic regression + +![inline](images/1dclasslinearprobs.png)![inline](images/1dclasslogisticprobs.png) + +--- + +## In diagram: + +![inline](images/layershorstd.png) + +--- + +## Softmax formulation + +- Identify $$p_i$$ and $$1-p_i$$ as two separate probabilities constrained to add to 1. That is $$p_{1i} = p_i ; p_{2i} = 1 - p_i. $$ + +- $$\renewcommand{\v}[1]{\mathbf #1} +p_{1i} = \frac{e^{\v{w_1} \cdot \v{x}}}{e^{\v{w_1} \cdot \v{x}} + e^{\v{w_2} \cdot \v{x}}}$$ + +- $$\renewcommand{\v}[1]{\mathbf #1} +p_{2i} = \frac{e^{\v{w_2} \cdot \v{x}}}{e^{\v{w_1} \cdot \v{x}} + e^{\v{w_2} \cdot \v{x}}}$$ +- Can translate coefficients by fixed amount $$\psi$$ without any change + +--- + +## NLL for Softmax + +$${\cal L} = \prod_i p_{1i}^{\mathbb1_1(y_i)} p_{2i}^{\mathbb1_2(y_i)}$$ + +$$NLL = -\sum_i \left( \mathbb1_1(y_i) log(p_{1i}) + \mathbb1_2(y_i) log(p_{2i}) \right)$$ + +--- + +## Units diagram for Softmax + +![inline](images/layershorsm.png) + +--- + +## Write it in Layers + +![inline](images/layershororig.png) + +--- + +## Equations, layer by layer + +$$\renewcommand{\v}[1]{\mathbf #1} +\v{z}^1 = \v{x_i}$$ + +$$\renewcommand{\v}[1]{\mathbf #1} +\v{z}^2 = (z^2_1, z^2_2) = (\v{w_1} \cdot \v{x_i}, \v{w_2} \cdot \v{x_i}) = (\v{w_1} \cdot \v{z^1_i}, \v{w_2} \cdot \v{z^1_i})$$ + +$$\renewcommand{\v}[1]{\mathbf #1} +\v{z}^3 = (z^3_1, z^3_2) = \left( LSM_1(z^2_1, z^2_2), LSM_2(z^2_1, z^2_2) \right)$$ + +$$\renewcommand{\v}[1]{\mathbf #1} +z^4 = NLL(\v{z}^3) = NLL(z^3_1, z^3_2) = - \sum_i \left( \mathbb1_1(y_i)z^3_1(i) + \mathbb1_2(y_i)z^3_1(i) \right)$$ + +--- + +## Dude, where is my network? + +$$\renewcommand{\v}[1]{\mathbf #1} +\v{z}^2 = (z^2_1, z^2_2) = (NN(\v{w_1} \cdot \v{x_i}), NN(\v{w_2} \cdot \v{x_i})) = (NN(\v{w_1} \cdot \v{z^1_i}), NN(\v{w_2} \cdot \v{z^1_i}))$$ + +Simply replace the linear regression here by a neural network. + +Now find gradients for SGD. + +--- + +#[fit]CLASSIFICATION + +#[fit]BY LINEAR SEPARATION + +#Which line? + +- Different Algorithms, different lines. + +- SVM uses max-margin[^j] + +![fit, right](/Users/rahul/Desktop/bookimages/linsep.pdf) + +--- + + +#DISCRIMINATIVE CLASSIFIER +$$P(y|x): P(male | height, weight)$$ + +![inline, fit](/Users/rahul/Desktop/presentationimages/logis.png)![inline, fit](/Users/rahul/Desktop/presentationimages/probalda.png) + +--- + +## Discriminative Learning + +- are these classifiers any good? +- they are discriminative and draw boundaries, but thats it +- could it be better to have a classifier that captured the generative process of the data? +- Thats Ai 2 + +--- + +## Calculating Gradients for learning: Backprop (Intuition) + +--- + +![inline](https://www.youtube.com/watch?v=Ilg3gGewQ5U) + +--- + +## Simple MLP for regression + +![inline](images/bps1.png) + + +--- + +![fit](images/layercake.png) + +--- + +## Forward Pass + +We want to obtain gradients. For example: $$\frac{\partial Cost}{\partial param} + = \frac{\partial z^6}{\partial w_1}$$ + +First we do the **Forward Pass**. Say we have 1 sample: (x=0.1, y=5). Initialize + $$b_1, w_1, b_2, w_2, w_{o1}, w_{o2}, b_{o}$$. Then, plugging in the numbers wi +ll give us some Cost ($$z^5, z^6$$). + + +![inline](images/bps4.png) + + +--- + +## Backward Pass + +Now it is time to find the gradients, for eg, $$\frac{\partial z^6}{\partial w_1}$$ + +The basic idea is to gather all parts that go to $$w_1$$, and so on and so forth. Now we perform GD (SGD) with some learning rate. + +The parameters get updated. Now we repeat the forward pass. + +Thats it! Wait for convergence. + +![right, fit](images/bps5.png) + +--- + +## Losses in Neural Nets + +![inline](images/lossandout.png) + +--- + +## How to fit? + +Our recipe has been: + +- Train a neural network until it overfits. +- Then add "regularization" + +But what is **Regularization**. + +Its a way to make parameters behave, to constrain them. + +--- + +## Many styles of regularization + +- Dropout +- L2/L1 Regularization: kernel regularization in Keras (also called weight decay) +- Early Stopping +- Simply add more data +- Data Augmentation + +--- + +## Dropout + +![left, fit](images/dropout.png) + +Dropout is a kind of pseudo layer. + +- choose a probability $$p$$ +- randomly sever $$p$$ of the connections from the previous layer in the training phase +- this forces other connections to take up the slack and prevents them from over-specializing +- in the testing phase multiply the learned weights with this probability but dont sever connections + +--- + +## L2 Norm + +![inline](images/noreg.png)![inline](images/nnreg.png) + +--- + +## Early Stopping + +![inline](images/earlystop.png) + +--- + +##[fit] Optimization + +--- + +# The workhorse: SGD + +- has one parameter, the learning rate +- the learning rate is how much of the gradient to use in your parameter updates +- the more you use, the faster you can train, and thus you dont get stuck in local minima +- but if you keep it large you bounce around stochastically + +--- + +# Messing with SGD + +- it would be better to have a learning rate schedule, or adaptive learning rates, perhaps different for each parameter +- SGD oscillates in high curvature areas +- averaging the gradient: $$$$ over a few steps helps as it eliminates oscillations +- momentum helps as well to keep you going straight down: + + $$v_{t+1} = \alpha v_t - \eta _t, w_{t+1} = w_t + v$$ + +![right, fit](images/newsgd1.png) + +--- + +# Other Variants + +- **Adagrad**: $$r_{t+1, j} = r_{t, j} + _{tj}^2, w_{t+1} = w_t - \eta \frac{_{tj}}{(\delta + \sqrt{r_{tj}})}$$ has greater progress along gently sloped directions +- **RMSprop** uses exponentially weighted average for gradient accumulation. Change to Adagrad: $$r_{t+1, j} = \rho r_{t, j} + (1 - \rho)_{tj}^2$$ +- **Adam** adds momentum to RMSprop works well in practice: + +$$r_{t+1, j} = \rho_r r_{t, j} + (1 - \rho_r)_{tj}^2$$, $$v_{t+1, j} = \rho_v v_{t, j} + (1 - \rho_v)_{tj}^2$$, $$ w_{t+1} = w_t - \eta \frac{v_{tj}}{(\delta + \sqrt{r_{tj}})}$$ + +--- + +## Other considerations + +- standardize your inputs(features) so no one input dominates +- we'll come back to Adam (later) +- parameter inittialization (Xavier vs He) (later) +- Batch normalization (later) \ No newline at end of file diff --git a/lecture.pdf b/lecture.pdf new file mode 100644 index 0000000..26e7a16 Binary files /dev/null and b/lecture.pdf differ diff --git a/linreg.ipynb b/linreg.ipynb new file mode 100644 index 0000000..14f034f --- /dev/null +++ b/linreg.ipynb @@ -0,0 +1,2066 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Linear Regression Multiple Ways" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Making the data\n", + "\n", + "We'll first construct a synthetic data set..using a function from the `scikit-learn` library. Synthetic data is nice in the sense that we can constrain how the noise behaves, and thus isolate effects." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from sklearn.datasets import make_regression\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#code adapted from http://tillbergmann.com/blog/python-gradient-descent.html\n", + "X, y, coef = make_regression(n_samples = 100, \n", + " n_features=1, \n", + " noise=20,\n", + " random_state=2017,\n", + " coef=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that the X is in the canonical array-of-arrays format.\n", + "**Try and print its shape**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are fitting a model with an intercept. Lets see what it is." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(80.88336208)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "coef" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can plot the data." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(X,y, 'o');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the purposes of drawing the regression line, lets create a uniform grid of points, and then reshape it into the canonical format" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "xgrid = np.linspace(-2.5,2.5,1000)\n", + "Xgrid = xgrid.reshape(-1,1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fit using sklearn" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LinearRegression" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([82.90456142]), -3.709228868670302)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lr = LinearRegression()\n", + "lr.fit(X,y)\n", + "ypgrid = lr.predict(Xgrid)\n", + "lr.coef_, lr.intercept_" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Xgrid, ypgrid)\n", + "plt.plot(X, y, '.')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import r2_score" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9342344891672815" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r2_score(y, lr.predict(X))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The impact of sample size\n", + "\n", + "We'll sample 20 points from the data set. We do this by sampling 20 indices, index into X and y, and then fit on the sample" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([98, 29, 6, 62, 5, 22, 91, 89, 94, 70, 75, 54, 94, 27, 88, 22, 45,\n", + " 30, 19, 7])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sample_indices = np.random.choice(range(100), size=20)\n", + "sample_indices" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "Xsample = X[sample_indices]\n", + "ysample = y[sample_indices]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.9421910899822037, 0.9421910899822037)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lr_s = LinearRegression().fit(Xsample, ysample)\n", + "r2_score(ysample, lr_s.predict(Xsample)), lr_s.score(Xsample, ysample)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets check the sensitivity of our prediction to our sample. We'll do this 1000 times" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.7, 1)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "scores = []\n", + "for i in range(1000):\n", + " sample_indices = np.random.choice(range(100), size=20)\n", + " Xsample = X[sample_indices]\n", + " ysample = y[sample_indices]\n", + " scores.append(LinearRegression().fit(Xsample, ysample).score(Xsample, ysample))\n", + "plt.hist(scores, bins=np.linspace(0.7, 1, 30))\n", + "plt.xlim(0.7,1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Redo this with a higher amount of noise (about 400). For this you will need to create a new dataset. Plot the data. Plot the histogram of the R^2 as well as that of the coefficients.Try a smaller dataset as well. What conclusions can you draw?" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "Xnew, ynew, coefnew = make_regression(n_samples = 100, \n", + " n_features=1, \n", + " noise=400,\n", + " random_state=2017,\n", + " coef=True)\n", + "plt.plot(Xnew, ynew, 'o');" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.7, 1)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "scores = []\n", + "models = []\n", + "for i in range(1000):\n", + " sample_indices = np.random.choice(range(100), size=20)\n", + " Xsample = X[sample_indices]\n", + " ysample = y[sample_indices]\n", + " models.append(LinearRegression().fit(Xsample, ysample))\n", + " scores.append(models[i].score(Xsample, ysample))\n", + "plt.hist(scores, bins=np.linspace(0.7, 1, 30));\n", + "plt.xlim(0.7,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.7, 1)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "scores = []\n", + "models = []\n", + "for i in range(1000):\n", + " sample_indices = np.random.choice(range(100), size=10)\n", + " Xsample = X[sample_indices]\n", + " ysample = y[sample_indices]\n", + " models.append(LinearRegression().fit(Xsample, ysample))\n", + " scores.append(models[i].score(Xsample, ysample))\n", + "plt.hist(scores, bins=np.linspace(0.7, 1, 30));\n", + "plt.xlim(0.7,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "plt.hist([models[i].coef_[0] for i in range(1000)], bins=10);" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "plt.hist([models[i].intercept_ for i in range(100)], bins=10);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing and training\n", + "\n", + "A grid like the one we created might contain some of the points we fit this model on. This is called **Data Contamination** and is a big no-no. If we want an independent estimate of the error, we should hold out some points in a test set." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "Xtrain, Xtest, ytrain, ytest = train_test_split(X, y, test_size=0.2, random_state=2017)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now lets fit the model on the training set and evaluate it both on the training set and the test set. We print the R^2" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "lr2 = LinearRegression().fit(Xtrain, ytrain)\n", + "r2_test = r2_score(ytest, lr.predict(Xtest))\n", + "r2_train = r2_score(ytrain, lr.predict(Xtrain))" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Train R2 is 0.9302930567263316, while test R^2 is 0.9446796445954511'" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"Train R2 is {}, while test R^2 is {}\".format(r2_train, r2_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using Keras to fit the model\n", + "\n", + "We'll use plain and simple gradient descent (why?) and Keras's Sequential API" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "dense_16 (Dense) (None, 1) 2 \n", + "=================================================================\n", + "Total params: 2\n", + "Trainable params: 2\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "from keras.models import Sequential\n", + "from keras.layers import Dense\n", + "lr3 = Sequential()\n", + "lr3.add(Dense(1, input_shape=(1,)))\n", + "lr3.compile(optimizer='sgd', loss='mean_squared_error', metrics=['mae','accuracy'])\n", + "lr3.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/400\n", + "80/80 [==============================] - 1s 8ms/step - loss: 5361.4824 - mean_absolute_error: 59.8523 - acc: 0.0000e+00\n", + "Epoch 2/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 5216.2017 - mean_absolute_error: 59.0328 - acc: 0.0000e+00\n", + "Epoch 3/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 5075.1665 - mean_absolute_error: 58.2255 - acc: 0.0000e+00\n", + "Epoch 4/400\n", + "80/80 [==============================] - 0s 23us/step - loss: 4938.2520 - mean_absolute_error: 57.4300 - acc: 0.0000e+00\n", + "Epoch 5/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 4805.3369 - mean_absolute_error: 56.6463 - acc: 0.0000e+00\n", + "Epoch 6/400\n", + "80/80 [==============================] - 0s 22us/step - loss: 4676.3037 - mean_absolute_error: 55.8877 - acc: 0.0000e+00\n", + "Epoch 7/400\n", + "80/80 [==============================] - 0s 20us/step - loss: 4551.0400 - mean_absolute_error: 55.1432 - acc: 0.0000e+00\n", + "Epoch 8/400\n", + "80/80 [==============================] - 0s 21us/step - loss: 4429.4346 - mean_absolute_error: 54.4204 - acc: 0.0000e+00\n", + "Epoch 9/400\n", + "80/80 [==============================] - 0s 19us/step - loss: 4311.3779 - mean_absolute_error: 53.7129 - acc: 0.0000e+00\n", + "Epoch 10/400\n", + "80/80 [==============================] - 0s 20us/step - loss: 4196.7686 - mean_absolute_error: 53.0277 - acc: 0.0000e+00\n", + "Epoch 11/400\n", + "80/80 [==============================] - 0s 22us/step - loss: 4085.5054 - mean_absolute_error: 52.3527 - acc: 0.0000e+00\n", + "Epoch 12/400\n", + "80/80 [==============================] - 0s 21us/step - loss: 3977.4888 - mean_absolute_error: 51.6875 - acc: 0.0000e+00\n", + "Epoch 13/400\n", + "80/80 [==============================] - 0s 21us/step - loss: 3872.6238 - mean_absolute_error: 51.0322 - acc: 0.0000e+00\n", + "Epoch 14/400\n", + "80/80 [==============================] - 0s 30us/step - loss: 3770.8196 - mean_absolute_error: 50.3865 - acc: 0.0000e+00\n", + "Epoch 15/400\n", + "80/80 [==============================] - 0s 23us/step - loss: 3671.9844 - mean_absolute_error: 49.7503 - acc: 0.0000e+00\n", + "Epoch 16/400\n", + "80/80 [==============================] - 0s 21us/step - loss: 3576.0332 - mean_absolute_error: 49.1235 - acc: 0.0000e+00\n", + "Epoch 17/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 3482.8796 - mean_absolute_error: 48.5060 - acc: 0.0000e+00\n", + "Epoch 18/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 3392.4438 - mean_absolute_error: 47.8975 - acc: 0.0000e+00\n", + "Epoch 19/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 3304.6440 - mean_absolute_error: 47.2980 - acc: 0.0000e+00\n", + "Epoch 20/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 3219.4048 - mean_absolute_error: 46.7073 - acc: 0.0000e+00\n", + "Epoch 21/400\n", + "80/80 [==============================] - 0s 28us/step - loss: 3136.6506 - mean_absolute_error: 46.1254 - acc: 0.0000e+00\n", + "Epoch 22/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 3056.3083 - mean_absolute_error: 45.5519 - acc: 0.0000e+00\n", + "Epoch 23/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 2978.3079 - mean_absolute_error: 44.9870 - acc: 0.0000e+00\n", + "Epoch 24/400\n", + "80/80 [==============================] - 0s 28us/step - loss: 2902.5806 - mean_absolute_error: 44.4303 - acc: 0.0000e+00\n", + "Epoch 25/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 2829.0598 - mean_absolute_error: 43.8819 - acc: 0.0000e+00\n", + "Epoch 26/400\n", + "80/80 [==============================] - 0s 44us/step - loss: 2757.6809 - mean_absolute_error: 43.3415 - acc: 0.0000e+00\n", + "Epoch 27/400\n", + "80/80 [==============================] - 0s 23us/step - loss: 2688.3816 - mean_absolute_error: 42.8091 - acc: 0.0000e+00\n", + "Epoch 28/400\n", + "80/80 [==============================] - 0s 23us/step - loss: 2621.1013 - mean_absolute_error: 42.2845 - acc: 0.0000e+00\n", + "Epoch 29/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 2555.7800 - mean_absolute_error: 41.7676 - acc: 0.0000e+00\n", + "Epoch 30/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 2492.3613 - mean_absolute_error: 41.2583 - acc: 0.0000e+00\n", + "Epoch 31/400\n", + "80/80 [==============================] - 0s 96us/step - loss: 2430.7896 - mean_absolute_error: 40.7566 - acc: 0.0000e+00\n", + "Epoch 32/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 2371.0103 - mean_absolute_error: 40.2622 - acc: 0.0000e+00\n", + "Epoch 33/400\n", + "80/80 [==============================] - 0s 62us/step - loss: 2312.9714 - mean_absolute_error: 39.7751 - acc: 0.0000e+00\n", + "Epoch 34/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 2256.6223 - mean_absolute_error: 39.2951 - acc: 0.0000e+00\n", + "Epoch 35/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 2201.9131 - mean_absolute_error: 38.8222 - acc: 0.0000e+00\n", + "Epoch 36/400\n", + "80/80 [==============================] - 0s 22us/step - loss: 2148.7961 - mean_absolute_error: 38.3563 - acc: 0.0000e+00\n", + "Epoch 37/400\n", + "80/80 [==============================] - 0s 38us/step - loss: 2097.2253 - mean_absolute_error: 37.8972 - acc: 0.0000e+00\n", + "Epoch 38/400\n", + "80/80 [==============================] - 0s 42us/step - loss: 2047.1547 - mean_absolute_error: 37.4449 - acc: 0.0000e+00\n", + "Epoch 39/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 1998.5413 - mean_absolute_error: 36.9992 - acc: 0.0000e+00\n", + "Epoch 40/400\n", + "80/80 [==============================] - 0s 39us/step - loss: 1951.3420 - mean_absolute_error: 36.5601 - acc: 0.0000e+00\n", + "Epoch 41/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 1905.5159 - mean_absolute_error: 36.1274 - acc: 0.0000e+00\n", + "Epoch 42/400\n", + "80/80 [==============================] - 0s 30us/step - loss: 1861.0227 - mean_absolute_error: 35.7011 - acc: 0.0000e+00\n", + "Epoch 43/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 1817.8236 - mean_absolute_error: 35.2811 - acc: 0.0000e+00\n", + "Epoch 44/400\n", + "80/80 [==============================] - 0s 22us/step - loss: 1775.8805 - mean_absolute_error: 34.8672 - acc: 0.0000e+00\n", + "Epoch 45/400\n", + "80/80 [==============================] - 0s 22us/step - loss: 1735.1572 - mean_absolute_error: 34.4595 - acc: 0.0000e+00\n", + "Epoch 46/400\n", + "80/80 [==============================] - 0s 21us/step - loss: 1695.6179 - mean_absolute_error: 34.0577 - acc: 0.0000e+00\n", + "Epoch 47/400\n", + "80/80 [==============================] - 0s 70us/step - loss: 1657.2285 - mean_absolute_error: 33.6618 - acc: 0.0000e+00\n", + "Epoch 48/400\n", + "80/80 [==============================] - 0s 48us/step - loss: 1619.9551 - mean_absolute_error: 33.2723 - acc: 0.0000e+00\n", + "Epoch 49/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 1583.7650 - mean_absolute_error: 32.8999 - acc: 0.0000e+00\n", + "Epoch 50/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 1548.6268 - mean_absolute_error: 32.5330 - acc: 0.0000e+00\n", + "Epoch 51/400\n", + "80/80 [==============================] - 0s 35us/step - loss: 1514.5098 - mean_absolute_error: 32.1760 - acc: 0.0000e+00\n", + "Epoch 52/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 1481.3845 - mean_absolute_error: 31.8261 - acc: 0.0000e+00\n", + "Epoch 53/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 1449.2217 - mean_absolute_error: 31.4813 - acc: 0.0000e+00\n", + "Epoch 54/400\n", + "80/80 [==============================] - 0s 53us/step - loss: 1417.9934 - mean_absolute_error: 31.1416 - acc: 0.0000e+00\n", + "Epoch 55/400\n", + "80/80 [==============================] - 0s 49us/step - loss: 1387.6721 - mean_absolute_error: 30.8069 - acc: 0.0000e+00\n", + "Epoch 56/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 1358.2319 - mean_absolute_error: 30.4770 - acc: 0.0000e+00\n", + "Epoch 57/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 1329.6469 - mean_absolute_error: 30.1520 - acc: 0.0000e+00\n", + "Epoch 58/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 1301.8922 - mean_absolute_error: 29.8330 - acc: 0.0000e+00\n", + "Epoch 59/400\n", + "80/80 [==============================] - 0s 50us/step - loss: 1274.9436 - mean_absolute_error: 29.5247 - acc: 0.0000e+00\n", + "Epoch 60/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 1248.7777 - mean_absolute_error: 29.2210 - acc: 0.0000e+00\n", + "Epoch 61/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 1223.3716 - mean_absolute_error: 28.9216 - acc: 0.0000e+00\n", + "Epoch 62/400\n", + "80/80 [==============================] - 0s 43us/step - loss: 1198.7031 - mean_absolute_error: 28.6266 - acc: 0.0000e+00\n", + "Epoch 63/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 1174.7511 - mean_absolute_error: 28.3360 - acc: 0.0000e+00\n", + "Epoch 64/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 1151.4945 - mean_absolute_error: 28.0495 - acc: 0.0000e+00\n", + "Epoch 65/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 1128.9127 - mean_absolute_error: 27.7673 - acc: 0.0000e+00\n", + "Epoch 66/400\n", + "80/80 [==============================] - 0s 33us/step - loss: 1106.9867 - mean_absolute_error: 27.4955 - acc: 0.0000e+00\n", + "Epoch 67/400\n", + "80/80 [==============================] - 0s 39us/step - loss: 1085.6970 - mean_absolute_error: 27.2355 - acc: 0.0000e+00\n", + "Epoch 68/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 1065.0254 - mean_absolute_error: 26.9793 - acc: 0.0000e+00\n", + "Epoch 69/400\n", + "80/80 [==============================] - 0s 30us/step - loss: 1044.9535 - mean_absolute_error: 26.7268 - acc: 0.0000e+00\n", + "Epoch 70/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 1025.4642 - mean_absolute_error: 26.4781 - acc: 0.0000e+00\n", + "Epoch 71/400\n", + "80/80 [==============================] - 0s 35us/step - loss: 1006.5404 - mean_absolute_error: 26.2329 - acc: 0.0000e+00\n", + "Epoch 72/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 988.1658 - mean_absolute_error: 25.9913 - acc: 0.0000e+00\n", + "Epoch 73/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 970.3243 - mean_absolute_error: 25.7533 - acc: 0.0000e+00\n", + "Epoch 74/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 953.0004 - mean_absolute_error: 25.5187 - acc: 0.0000e+00\n", + "Epoch 75/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 936.1791 - mean_absolute_error: 25.2876 - acc: 0.0000e+00\n", + "Epoch 76/400\n", + "80/80 [==============================] - 0s 22us/step - loss: 919.8456 - mean_absolute_error: 25.0615 - acc: 0.0000e+00\n", + "Epoch 77/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 903.9861 - mean_absolute_error: 24.8401 - acc: 0.0000e+00\n", + "Epoch 78/400\n", + "80/80 [==============================] - 0s 35us/step - loss: 888.5863 - mean_absolute_error: 24.6219 - acc: 0.0000e+00\n", + "Epoch 79/400\n", + "80/80 [==============================] - 0s 22us/step - loss: 873.6335 - mean_absolute_error: 24.4069 - acc: 0.0000e+00\n", + "Epoch 80/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 859.1141 - mean_absolute_error: 24.1950 - acc: 0.0000e+00\n", + "Epoch 81/400\n", + "80/80 [==============================] - 0s 30us/step - loss: 845.0158 - mean_absolute_error: 23.9862 - acc: 0.0000e+00\n", + "Epoch 82/400\n", + "80/80 [==============================] - 0s 23us/step - loss: 831.3263 - mean_absolute_error: 23.7804 - acc: 0.0000e+00\n", + "Epoch 83/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 818.0336 - mean_absolute_error: 23.5835 - acc: 0.0000e+00\n", + "Epoch 84/400\n", + "80/80 [==============================] - 0s 20us/step - loss: 805.1266 - mean_absolute_error: 23.4010 - acc: 0.0000e+00\n", + "Epoch 85/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 792.5936 - mean_absolute_error: 23.2212 - acc: 0.0000e+00\n", + "Epoch 86/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 780.4240 - mean_absolute_error: 23.0440 - acc: 0.0000e+00\n", + "Epoch 87/400\n", + "80/80 [==============================] - 0s 47us/step - loss: 768.6071 - mean_absolute_error: 22.8694 - acc: 0.0000e+00\n", + "Epoch 88/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 757.1329 - mean_absolute_error: 22.6973 - acc: 0.0000e+00\n", + "Epoch 89/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 745.9910 - mean_absolute_error: 22.5277 - acc: 0.0000e+00\n", + "Epoch 90/400\n", + "80/80 [==============================] - 0s 75us/step - loss: 735.1722 - mean_absolute_error: 22.3606 - acc: 0.0000e+00\n", + "Epoch 91/400\n", + "80/80 [==============================] - 0s 33us/step - loss: 724.6669 - mean_absolute_error: 22.1959 - acc: 0.0000e+00\n", + "Epoch 92/400\n", + "80/80 [==============================] - 0s 28us/step - loss: 714.4661 - mean_absolute_error: 22.0337 - acc: 0.0000e+00\n", + "Epoch 93/400\n", + "80/80 [==============================] - 0s 61us/step - loss: 704.5609 - mean_absolute_error: 21.8738 - acc: 0.0000e+00\n", + "Epoch 94/400\n", + "80/80 [==============================] - 0s 55us/step - loss: 694.9426 - mean_absolute_error: 21.7162 - acc: 0.0000e+00\n", + "Epoch 95/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 685.6031 - mean_absolute_error: 21.5627 - acc: 0.0000e+00\n", + "Epoch 96/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 676.5342 - mean_absolute_error: 21.4176 - acc: 0.0000e+00\n", + "Epoch 97/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 667.7280 - mean_absolute_error: 21.2788 - acc: 0.0000e+00\n", + "Epoch 98/400\n", + "80/80 [==============================] - 0s 33us/step - loss: 659.1769 - mean_absolute_error: 21.1420 - acc: 0.0000e+00\n", + "Epoch 99/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 650.8737 - mean_absolute_error: 21.0072 - acc: 0.0000e+00\n", + "Epoch 100/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 642.8108 - mean_absolute_error: 20.8743 - acc: 0.0000e+00\n", + "Epoch 101/400\n", + "80/80 [==============================] - 0s 35us/step - loss: 634.9816 - mean_absolute_error: 20.7434 - acc: 0.0000e+00\n", + "Epoch 102/400\n", + "80/80 [==============================] - 0s 38us/step - loss: 627.3790 - mean_absolute_error: 20.6144 - acc: 0.0000e+00\n", + "Epoch 103/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 619.9968 - mean_absolute_error: 20.4872 - acc: 0.0000e+00\n", + "Epoch 104/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 612.8282 - mean_absolute_error: 20.3667 - acc: 0.0000e+00\n", + "Epoch 105/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 605.8673 - mean_absolute_error: 20.2493 - acc: 0.0000e+00\n", + "Epoch 106/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 599.1079 - mean_absolute_error: 20.1344 - acc: 0.0000e+00\n", + "Epoch 107/400\n", + "80/80 [==============================] - 0s 36us/step - loss: 592.5443 - mean_absolute_error: 20.0236 - acc: 0.0000e+00\n", + "Epoch 108/400\n", + "80/80 [==============================] - 0s 50us/step - loss: 586.1708 - mean_absolute_error: 19.9143 - acc: 0.0000e+00\n", + "Epoch 109/400\n", + "80/80 [==============================] - 0s 53us/step - loss: 579.9819 - mean_absolute_error: 19.8067 - acc: 0.0000e+00\n", + "Epoch 110/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 573.9722 - mean_absolute_error: 19.7006 - acc: 0.0000e+00\n", + "Epoch 111/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 568.1364 - mean_absolute_error: 19.5960 - acc: 0.0000e+00\n", + "Epoch 112/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 562.4694 - mean_absolute_error: 19.4929 - acc: 0.0000e+00\n", + "Epoch 113/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 556.9667 - mean_absolute_error: 19.3913 - acc: 0.0000e+00\n", + "Epoch 114/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 551.6233 - mean_absolute_error: 19.2912 - acc: 0.0000e+00\n", + "Epoch 115/400\n", + "80/80 [==============================] - 0s 21us/step - loss: 546.4344 - mean_absolute_error: 19.1925 - acc: 0.0000e+00\n", + "Epoch 116/400\n", + "80/80 [==============================] - 0s 23us/step - loss: 541.3959 - mean_absolute_error: 19.0953 - acc: 0.0000e+00\n", + "Epoch 117/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 536.5031 - mean_absolute_error: 19.0072 - acc: 0.0000e+00\n", + "Epoch 118/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 531.7518 - mean_absolute_error: 18.9220 - acc: 0.0000e+00\n", + "Epoch 119/400\n", + "80/80 [==============================] - 0s 21us/step - loss: 527.1381 - mean_absolute_error: 18.8381 - acc: 0.0000e+00\n", + "Epoch 120/400\n", + "80/80 [==============================] - 0s 49us/step - loss: 522.6578 - mean_absolute_error: 18.7590 - acc: 0.0000e+00\n", + "Epoch 121/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 518.3074 - mean_absolute_error: 18.6850 - acc: 0.0000e+00\n", + "Epoch 122/400\n", + "80/80 [==============================] - 0s 40us/step - loss: 514.0828 - mean_absolute_error: 18.6121 - acc: 0.0000e+00\n", + "Epoch 123/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 509.9805 - mean_absolute_error: 18.5402 - acc: 0.0000e+00\n", + "Epoch 124/400\n", + "80/80 [==============================] - 0s 33us/step - loss: 505.9968 - mean_absolute_error: 18.4694 - acc: 0.0000e+00\n", + "Epoch 125/400\n", + "80/80 [==============================] - 0s 33us/step - loss: 502.1284 - mean_absolute_error: 18.4050 - acc: 0.0000e+00\n", + "Epoch 126/400\n", + "80/80 [==============================] - 0s 23us/step - loss: 498.3719 - mean_absolute_error: 18.3420 - acc: 0.0000e+00\n", + "Epoch 127/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 494.7242 - mean_absolute_error: 18.2800 - acc: 0.0000e+00\n", + "Epoch 128/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 491.1820 - mean_absolute_error: 18.2189 - acc: 0.0000e+00\n", + "Epoch 129/400\n", + "80/80 [==============================] - 0s 30us/step - loss: 487.7423 - mean_absolute_error: 18.1586 - acc: 0.0000e+00\n", + "Epoch 130/400\n", + "80/80 [==============================] - 0s 28us/step - loss: 484.4020 - mean_absolute_error: 18.0993 - acc: 0.0000e+00\n", + "Epoch 131/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 481.1585 - mean_absolute_error: 18.0408 - acc: 0.0000e+00\n", + "Epoch 132/400\n", + "80/80 [==============================] - 0s 48us/step - loss: 478.0087 - mean_absolute_error: 17.9831 - acc: 0.0000e+00\n", + "Epoch 133/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 474.9500 - mean_absolute_error: 17.9263 - acc: 0.0000e+00\n", + "Epoch 134/400\n", + "80/80 [==============================] - 0s 43us/step - loss: 471.9799 - mean_absolute_error: 17.8703 - acc: 0.0000e+00\n", + "Epoch 135/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 469.0956 - mean_absolute_error: 17.8152 - acc: 0.0000e+00\n", + "Epoch 136/400\n", + "80/80 [==============================] - 0s 46us/step - loss: 466.2947 - mean_absolute_error: 17.7608 - acc: 0.0000e+00\n", + "Epoch 137/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 463.5749 - mean_absolute_error: 17.7072 - acc: 0.0000e+00\n", + "Epoch 138/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 460.9336 - mean_absolute_error: 17.6544 - acc: 0.0000e+00\n", + "Epoch 139/400\n", + "80/80 [==============================] - 0s 78us/step - loss: 458.3689 - mean_absolute_error: 17.6070 - acc: 0.0000e+00\n", + "Epoch 140/400\n", + "80/80 [==============================] - 0s 54us/step - loss: 455.8783 - mean_absolute_error: 17.5605 - acc: 0.0000e+00\n", + "Epoch 141/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 453.4597 - mean_absolute_error: 17.5147 - acc: 0.0000e+00\n", + "Epoch 142/400\n", + "80/80 [==============================] - 0s 93us/step - loss: 451.1110 - mean_absolute_error: 17.4696 - acc: 0.0000e+00\n", + "Epoch 143/400\n", + "80/80 [==============================] - 0s 30us/step - loss: 448.8303 - mean_absolute_error: 17.4251 - acc: 0.0000e+00\n", + "Epoch 144/400\n", + "80/80 [==============================] - 0s 367us/step - loss: 446.6155 - mean_absolute_error: 17.3813 - acc: 0.0000e+00\n", + "Epoch 145/400\n", + "80/80 [==============================] - 0s 212us/step - loss: 444.4648 - mean_absolute_error: 17.3426 - acc: 0.0000e+00\n", + "Epoch 146/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 442.3763 - mean_absolute_error: 17.3054 - acc: 0.0000e+00\n", + "Epoch 147/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 440.3481 - mean_absolute_error: 17.2688 - acc: 0.0000e+00\n", + "Epoch 148/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 438.3787 - mean_absolute_error: 17.2327 - acc: 0.0000e+00\n", + "Epoch 149/400\n", + "80/80 [==============================] - 0s 185us/step - loss: 436.4661 - mean_absolute_error: 17.2007 - acc: 0.0000e+00\n", + "Epoch 150/400\n", + "80/80 [==============================] - 0s 45us/step - loss: 434.6089 - mean_absolute_error: 17.1698 - acc: 0.0000e+00\n", + "Epoch 151/400\n", + "80/80 [==============================] - 0s 57us/step - loss: 432.8053 - mean_absolute_error: 17.1393 - acc: 0.0000e+00\n", + "Epoch 152/400\n", + "80/80 [==============================] - 0s 33us/step - loss: 431.0538 - mean_absolute_error: 17.1093 - acc: 0.0000e+00\n", + "Epoch 153/400\n", + "80/80 [==============================] - 0s 68us/step - loss: 429.3530 - mean_absolute_error: 17.0798 - acc: 0.0000e+00\n", + "Epoch 154/400\n", + "80/80 [==============================] - 0s 48us/step - loss: 427.7014 - mean_absolute_error: 17.0506 - acc: 0.0000e+00\n", + "Epoch 155/400\n", + "80/80 [==============================] - 0s 36us/step - loss: 426.0975 - mean_absolute_error: 17.0219 - acc: 0.0000e+00\n", + "Epoch 156/400\n", + "80/80 [==============================] - 0s 60us/step - loss: 424.5399 - mean_absolute_error: 16.9936 - acc: 0.0000e+00\n", + "Epoch 157/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 423.0274 - mean_absolute_error: 16.9657 - acc: 0.0000e+00\n", + "Epoch 158/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 421.5586 - mean_absolute_error: 16.9382 - acc: 0.0000e+00\n", + "Epoch 159/400\n", + "80/80 [==============================] - 0s 50us/step - loss: 420.1322 - mean_absolute_error: 16.9111 - acc: 0.0000e+00\n", + "Epoch 160/400\n", + "80/80 [==============================] - 0s 50us/step - loss: 418.7470 - mean_absolute_error: 16.8844 - acc: 0.0000e+00\n", + "Epoch 161/400\n", + "80/80 [==============================] - 0s 48us/step - loss: 417.4020 - mean_absolute_error: 16.8581 - acc: 0.0000e+00\n", + "Epoch 162/400\n", + "80/80 [==============================] - 0s 44us/step - loss: 416.0957 - mean_absolute_error: 16.8322 - acc: 0.0000e+00\n", + "Epoch 163/400\n", + "80/80 [==============================] - 0s 52us/step - loss: 414.8272 - mean_absolute_error: 16.8074 - acc: 0.0000e+00\n", + "Epoch 164/400\n", + "80/80 [==============================] - 0s 47us/step - loss: 413.5954 - mean_absolute_error: 16.7844 - acc: 0.0000e+00\n", + "Epoch 165/400\n", + "80/80 [==============================] - 0s 48us/step - loss: 412.3992 - mean_absolute_error: 16.7617 - acc: 0.0000e+00\n", + "Epoch 166/400\n", + "80/80 [==============================] - 0s 55us/step - loss: 411.2375 - mean_absolute_error: 16.7393 - acc: 0.0000e+00\n", + "Epoch 167/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 410.1095 - mean_absolute_error: 16.7185 - acc: 0.0000e+00\n", + "Epoch 168/400\n", + "80/80 [==============================] - 0s 65us/step - loss: 409.0140 - mean_absolute_error: 16.7000 - acc: 0.0000e+00\n", + "Epoch 169/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 407.9501 - mean_absolute_error: 16.6837 - acc: 0.0000e+00\n", + "Epoch 170/400\n", + "80/80 [==============================] - 0s 23us/step - loss: 406.9170 - mean_absolute_error: 16.6678 - acc: 0.0000e+00\n", + "Epoch 171/400\n", + "80/80 [==============================] - 0s 39us/step - loss: 405.9138 - mean_absolute_error: 16.6520 - acc: 0.0000e+00\n", + "Epoch 172/400\n", + "80/80 [==============================] - 0s 40us/step - loss: 404.9395 - mean_absolute_error: 16.6372 - acc: 0.0000e+00\n", + "Epoch 173/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 403.9934 - mean_absolute_error: 16.6239 - acc: 0.0000e+00\n", + "Epoch 174/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 403.0746 - mean_absolute_error: 16.6108 - acc: 0.0000e+00\n", + "Epoch 175/400\n", + "80/80 [==============================] - 0s 39us/step - loss: 402.1824 - mean_absolute_error: 16.5978 - acc: 0.0000e+00\n", + "Epoch 176/400\n", + "80/80 [==============================] - 0s 35us/step - loss: 401.3160 - mean_absolute_error: 16.5851 - acc: 0.0000e+00\n", + "Epoch 177/400\n", + "80/80 [==============================] - 0s 35us/step - loss: 400.4745 - mean_absolute_error: 16.5726 - acc: 0.0000e+00\n", + "Epoch 178/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 399.6574 - mean_absolute_error: 16.5602 - acc: 0.0000e+00\n", + "Epoch 179/400\n", + "80/80 [==============================] - 0s 30us/step - loss: 398.8640 - mean_absolute_error: 16.5480 - acc: 0.0000e+00\n", + "Epoch 180/400\n", + "80/80 [==============================] - 0s 36us/step - loss: 398.0934 - mean_absolute_error: 16.5360 - acc: 0.0000e+00\n", + "Epoch 181/400\n", + "80/80 [==============================] - 0s 30us/step - loss: 397.3450 - mean_absolute_error: 16.5242 - acc: 0.0000e+00\n", + "Epoch 182/400\n", + "80/80 [==============================] - 0s 30us/step - loss: 396.6183 - mean_absolute_error: 16.5126 - acc: 0.0000e+00\n", + "Epoch 183/400\n", + "80/80 [==============================] - 0s 33us/step - loss: 395.9126 - mean_absolute_error: 16.5011 - acc: 0.0000e+00\n", + "Epoch 184/400\n", + "80/80 [==============================] - 0s 33us/step - loss: 395.2273 - mean_absolute_error: 16.4898 - acc: 0.0000e+00\n", + "Epoch 185/400\n", + "80/80 [==============================] - 0s 46us/step - loss: 394.5618 - mean_absolute_error: 16.4786 - acc: 0.0000e+00\n", + "Epoch 186/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 393.9155 - mean_absolute_error: 16.4677 - acc: 0.0000e+00\n", + "Epoch 187/400\n", + "80/80 [==============================] - 0s 43us/step - loss: 393.2879 - mean_absolute_error: 16.4568 - acc: 0.0000e+00\n", + "Epoch 188/400\n", + "80/80 [==============================] - 0s 28us/step - loss: 392.6784 - mean_absolute_error: 16.4462 - acc: 0.0000e+00\n", + "Epoch 189/400\n", + "80/80 [==============================] - 0s 38us/step - loss: 392.0865 - mean_absolute_error: 16.4357 - acc: 0.0000e+00\n", + "Epoch 190/400\n", + "80/80 [==============================] - 0s 75us/step - loss: 391.5117 - mean_absolute_error: 16.4253 - acc: 0.0000e+00\n", + "Epoch 191/400\n", + "80/80 [==============================] - 0s 49us/step - loss: 390.9534 - mean_absolute_error: 16.4151 - acc: 0.0000e+00\n", + "Epoch 192/400\n", + "80/80 [==============================] - 0s 50us/step - loss: 390.4113 - mean_absolute_error: 16.4051 - acc: 0.0000e+00\n", + "Epoch 193/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 389.8849 - mean_absolute_error: 16.3952 - acc: 0.0000e+00\n", + "Epoch 194/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 389.3737 - mean_absolute_error: 16.3854 - acc: 0.0000e+00\n", + "Epoch 195/400\n", + "80/80 [==============================] - 0s 35us/step - loss: 388.8773 - mean_absolute_error: 16.3758 - acc: 0.0000e+00\n", + "Epoch 196/400\n", + "80/80 [==============================] - 0s 28us/step - loss: 388.3951 - mean_absolute_error: 16.3664 - acc: 0.0000e+00\n", + "Epoch 197/400\n", + "80/80 [==============================] - 0s 38us/step - loss: 387.9269 - mean_absolute_error: 16.3570 - acc: 0.0000e+00\n", + "Epoch 198/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 387.4723 - mean_absolute_error: 16.3478 - acc: 0.0000e+00\n", + "Epoch 199/400\n", + "80/80 [==============================] - 0s 49us/step - loss: 387.0308 - mean_absolute_error: 16.3388 - acc: 0.0000e+00\n", + "Epoch 200/400\n", + "80/80 [==============================] - 0s 39us/step - loss: 386.6020 - mean_absolute_error: 16.3299 - acc: 0.0000e+00\n", + "Epoch 201/400\n", + "80/80 [==============================] - 0s 35us/step - loss: 386.1856 - mean_absolute_error: 16.3218 - acc: 0.0000e+00\n", + "Epoch 202/400\n", + "80/80 [==============================] - 0s 106us/step - loss: 385.7812 - mean_absolute_error: 16.3151 - acc: 0.0000e+00\n", + "Epoch 203/400\n", + "80/80 [==============================] - 0s 57us/step - loss: 385.3885 - mean_absolute_error: 16.3084 - acc: 0.0000e+00\n", + "Epoch 204/400\n", + "80/80 [==============================] - 0s 38us/step - loss: 385.0071 - mean_absolute_error: 16.3019 - acc: 0.0000e+00\n", + "Epoch 205/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 384.6367 - mean_absolute_error: 16.2966 - acc: 0.0000e+00\n", + "Epoch 206/400\n", + "80/80 [==============================] - 0s 46us/step - loss: 384.2770 - mean_absolute_error: 16.2916 - acc: 0.0000e+00\n", + "Epoch 207/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 383.9278 - mean_absolute_error: 16.2868 - acc: 0.0000e+00\n", + "Epoch 208/400\n", + "80/80 [==============================] - 0s 49us/step - loss: 383.5886 - mean_absolute_error: 16.2820 - acc: 0.0000e+00\n", + "Epoch 209/400\n", + "80/80 [==============================] - 0s 59us/step - loss: 383.2592 - mean_absolute_error: 16.2772 - acc: 0.0000e+00\n", + "Epoch 210/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 382.9393 - mean_absolute_error: 16.2726 - acc: 0.0000e+00\n", + "Epoch 211/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 382.6286 - mean_absolute_error: 16.2680 - acc: 0.0000e+00\n", + "Epoch 212/400\n", + "80/80 [==============================] - 0s 40us/step - loss: 382.3270 - mean_absolute_error: 16.2635 - acc: 0.0000e+00\n", + "Epoch 213/400\n", + "80/80 [==============================] - 0s 148us/step - loss: 382.0340 - mean_absolute_error: 16.2590 - acc: 0.0000e+00\n", + "Epoch 214/400\n", + "80/80 [==============================] - 0s 39us/step - loss: 381.7495 - mean_absolute_error: 16.2546 - acc: 0.0000e+00\n", + "Epoch 215/400\n", + "80/80 [==============================] - 0s 46us/step - loss: 381.4732 - mean_absolute_error: 16.2503 - acc: 0.0000e+00\n", + "Epoch 216/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 381.2049 - mean_absolute_error: 16.2460 - acc: 0.0000e+00\n", + "Epoch 217/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 380.9442 - mean_absolute_error: 16.2418 - acc: 0.0000e+00\n", + "Epoch 218/400\n", + "80/80 [==============================] - 0s 21us/step - loss: 380.6913 - mean_absolute_error: 16.2376 - acc: 0.0000e+00\n", + "Epoch 219/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 380.4455 - mean_absolute_error: 16.2335 - acc: 0.0000e+00\n", + "Epoch 220/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 380.2069 - mean_absolute_error: 16.2295 - acc: 0.0000e+00\n", + "Epoch 221/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 379.9751 - mean_absolute_error: 16.2255 - acc: 0.0000e+00\n", + "Epoch 222/400\n", + "80/80 [==============================] - 0s 45us/step - loss: 379.7500 - mean_absolute_error: 16.2216 - acc: 0.0000e+00\n", + "Epoch 223/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 379.5314 - mean_absolute_error: 16.2178 - acc: 0.0000e+00\n", + "Epoch 224/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 379.3192 - mean_absolute_error: 16.2140 - acc: 0.0000e+00\n", + "Epoch 225/400\n", + "80/80 [==============================] - 0s 53us/step - loss: 379.1130 - mean_absolute_error: 16.2102 - acc: 0.0000e+00\n", + "Epoch 226/400\n", + "80/80 [==============================] - 0s 40us/step - loss: 378.9128 - mean_absolute_error: 16.2065 - acc: 0.0000e+00\n", + "Epoch 227/400\n", + "80/80 [==============================] - 0s 46us/step - loss: 378.7184 - mean_absolute_error: 16.2029 - acc: 0.0000e+00\n", + "Epoch 228/400\n", + "80/80 [==============================] - 0s 42us/step - loss: 378.5296 - mean_absolute_error: 16.1993 - acc: 0.0000e+00\n", + "Epoch 229/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 378.3463 - mean_absolute_error: 16.1958 - acc: 0.0000e+00\n", + "Epoch 230/400\n", + "80/80 [==============================] - 0s 28us/step - loss: 378.1682 - mean_absolute_error: 16.1923 - acc: 0.0000e+00\n", + "Epoch 231/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 377.9953 - mean_absolute_error: 16.1889 - acc: 0.0000e+00\n", + "Epoch 232/400\n", + "80/80 [==============================] - 0s 35us/step - loss: 377.8274 - mean_absolute_error: 16.1855 - acc: 0.0000e+00\n", + "Epoch 233/400\n", + "80/80 [==============================] - 0s 38us/step - loss: 377.6643 - mean_absolute_error: 16.1821 - acc: 0.0000e+00\n", + "Epoch 234/400\n", + "80/80 [==============================] - 0s 161us/step - loss: 377.5059 - mean_absolute_error: 16.1788 - acc: 0.0000e+00\n", + "Epoch 235/400\n", + "80/80 [==============================] - 0s 56us/step - loss: 377.3521 - mean_absolute_error: 16.1756 - acc: 0.0000e+00\n", + "Epoch 236/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 377.2028 - mean_absolute_error: 16.1724 - acc: 0.0000e+00\n", + "Epoch 237/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 377.0577 - mean_absolute_error: 16.1693 - acc: 0.0000e+00\n", + "Epoch 238/400\n", + "80/80 [==============================] - 0s 71us/step - loss: 376.9168 - mean_absolute_error: 16.1662 - acc: 0.0000e+00\n", + "Epoch 239/400\n", + "80/80 [==============================] - 0s 39us/step - loss: 376.7800 - mean_absolute_error: 16.1631 - acc: 0.0000e+00\n", + "Epoch 240/400\n", + "80/80 [==============================] - 0s 28us/step - loss: 376.6472 - mean_absolute_error: 16.1601 - acc: 0.0000e+00\n", + "Epoch 241/400\n", + "80/80 [==============================] - 0s 82us/step - loss: 376.5182 - mean_absolute_error: 16.1580 - acc: 0.0000e+00\n", + "Epoch 242/400\n", + "80/80 [==============================] - 0s 57us/step - loss: 376.3929 - mean_absolute_error: 16.1563 - acc: 0.0000e+00\n", + "Epoch 243/400\n", + "80/80 [==============================] - 0s 54us/step - loss: 376.2712 - mean_absolute_error: 16.1546 - acc: 0.0000e+00\n", + "Epoch 244/400\n", + "80/80 [==============================] - 0s 40us/step - loss: 376.1531 - mean_absolute_error: 16.1530 - acc: 0.0000e+00\n", + "Epoch 245/400\n", + "80/80 [==============================] - 0s 33us/step - loss: 376.0383 - mean_absolute_error: 16.1513 - acc: 0.0000e+00\n", + "Epoch 246/400\n", + "80/80 [==============================] - 0s 76us/step - loss: 375.9269 - mean_absolute_error: 16.1497 - acc: 0.0000e+00\n", + "Epoch 247/400\n", + "80/80 [==============================] - 0s 35us/step - loss: 375.8187 - mean_absolute_error: 16.1481 - acc: 0.0000e+00\n", + "Epoch 248/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 375.7136 - mean_absolute_error: 16.1465 - acc: 0.0000e+00\n", + "Epoch 249/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 375.6115 - mean_absolute_error: 16.1450 - acc: 0.0000e+00\n", + "Epoch 250/400\n", + "80/80 [==============================] - 0s 59us/step - loss: 375.5124 - mean_absolute_error: 16.1434 - acc: 0.0000e+00\n", + "Epoch 251/400\n", + "80/80 [==============================] - 0s 51us/step - loss: 375.4161 - mean_absolute_error: 16.1419 - acc: 0.0000e+00\n", + "Epoch 252/400\n", + "80/80 [==============================] - 0s 28us/step - loss: 375.3226 - mean_absolute_error: 16.1405 - acc: 0.0000e+00\n", + "Epoch 253/400\n", + "80/80 [==============================] - 0s 59us/step - loss: 375.2318 - mean_absolute_error: 16.1390 - acc: 0.0000e+00\n", + "Epoch 254/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 375.1436 - mean_absolute_error: 16.1375 - acc: 0.0000e+00\n", + "Epoch 255/400\n", + "80/80 [==============================] - 0s 58us/step - loss: 375.0580 - mean_absolute_error: 16.1361 - acc: 0.0000e+00\n", + "Epoch 256/400\n", + "80/80 [==============================] - 0s 49us/step - loss: 374.9749 - mean_absolute_error: 16.1347 - acc: 0.0000e+00\n", + "Epoch 257/400\n", + "80/80 [==============================] - 0s 46us/step - loss: 374.8941 - mean_absolute_error: 16.1333 - acc: 0.0000e+00\n", + "Epoch 258/400\n", + "80/80 [==============================] - 0s 47us/step - loss: 374.8157 - mean_absolute_error: 16.1320 - acc: 0.0000e+00\n", + "Epoch 259/400\n", + "80/80 [==============================] - 0s 43us/step - loss: 374.7396 - mean_absolute_error: 16.1306 - acc: 0.0000e+00\n", + "Epoch 260/400\n", + "80/80 [==============================] - 0s 45us/step - loss: 374.6656 - mean_absolute_error: 16.1293 - acc: 0.0000e+00\n", + "Epoch 261/400\n", + "80/80 [==============================] - 0s 55us/step - loss: 374.5938 - mean_absolute_error: 16.1280 - acc: 0.0000e+00\n", + "Epoch 262/400\n", + "80/80 [==============================] - 0s 23us/step - loss: 374.5240 - mean_absolute_error: 16.1267 - acc: 0.0000e+00\n", + "Epoch 263/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 374.4563 - mean_absolute_error: 16.1255 - acc: 0.0000e+00\n", + "Epoch 264/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 374.3905 - mean_absolute_error: 16.1242 - acc: 0.0000e+00\n", + "Epoch 265/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 374.3266 - mean_absolute_error: 16.1230 - acc: 0.0000e+00\n", + "Epoch 266/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 374.2646 - mean_absolute_error: 16.1218 - acc: 0.0000e+00\n", + "Epoch 267/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 374.2043 - mean_absolute_error: 16.1206 - acc: 0.0000e+00\n", + "Epoch 268/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 374.1458 - mean_absolute_error: 16.1194 - acc: 0.0000e+00\n", + "Epoch 269/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 374.0890 - mean_absolute_error: 16.1183 - acc: 0.0000e+00\n", + "Epoch 270/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 374.0338 - mean_absolute_error: 16.1171 - acc: 0.0000e+00\n", + "Epoch 271/400\n", + "80/80 [==============================] - 0s 36us/step - loss: 373.9802 - mean_absolute_error: 16.1160 - acc: 0.0000e+00\n", + "Epoch 272/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 373.9282 - mean_absolute_error: 16.1149 - acc: 0.0000e+00\n", + "Epoch 273/400\n", + "80/80 [==============================] - 0s 33us/step - loss: 373.8776 - mean_absolute_error: 16.1138 - acc: 0.0000e+00\n", + "Epoch 274/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 373.8286 - mean_absolute_error: 16.1127 - acc: 0.0000e+00\n", + "Epoch 275/400\n", + "80/80 [==============================] - 0s 71us/step - loss: 373.7809 - mean_absolute_error: 16.1117 - acc: 0.0000e+00\n", + "Epoch 276/400\n", + "80/80 [==============================] - 0s 35us/step - loss: 373.7346 - mean_absolute_error: 16.1106 - acc: 0.0000e+00\n", + "Epoch 277/400\n", + "80/80 [==============================] - 0s 154us/step - loss: 373.6896 - mean_absolute_error: 16.1096 - acc: 0.0000e+00\n", + "Epoch 278/400\n", + "80/80 [==============================] - 0s 63us/step - loss: 373.6459 - mean_absolute_error: 16.1086 - acc: 0.0000e+00\n", + "Epoch 279/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 373.6035 - mean_absolute_error: 16.1076 - acc: 0.0000e+00\n", + "Epoch 280/400\n", + "80/80 [==============================] - 0s 22us/step - loss: 373.5624 - mean_absolute_error: 16.1066 - acc: 0.0000e+00\n", + "Epoch 281/400\n", + "80/80 [==============================] - 0s 42us/step - loss: 373.5224 - mean_absolute_error: 16.1057 - acc: 0.0000e+00\n", + "Epoch 282/400\n", + "80/80 [==============================] - 0s 23us/step - loss: 373.4836 - mean_absolute_error: 16.1053 - acc: 0.0000e+00\n", + "Epoch 283/400\n", + "80/80 [==============================] - 0s 44us/step - loss: 373.4458 - mean_absolute_error: 16.1049 - acc: 0.0000e+00\n", + "Epoch 284/400\n", + "80/80 [==============================] - 0s 67us/step - loss: 373.4092 - mean_absolute_error: 16.1044 - acc: 0.0000e+00\n", + "Epoch 285/400\n", + "80/80 [==============================] - 0s 49us/step - loss: 373.3737 - mean_absolute_error: 16.1040 - acc: 0.0000e+00\n", + "Epoch 286/400\n", + "80/80 [==============================] - 0s 197us/step - loss: 373.3391 - mean_absolute_error: 16.1036 - acc: 0.0000e+00\n", + "Epoch 287/400\n", + "80/80 [==============================] - 0s 51us/step - loss: 373.3055 - mean_absolute_error: 16.1032 - acc: 0.0000e+00\n", + "Epoch 288/400\n", + "80/80 [==============================] - 0s 216us/step - loss: 373.2730 - mean_absolute_error: 16.1027 - acc: 0.0000e+00\n", + "Epoch 289/400\n", + "80/80 [==============================] - 0s 81us/step - loss: 373.2414 - mean_absolute_error: 16.1023 - acc: 0.0000e+00\n", + "Epoch 290/400\n", + "80/80 [==============================] - 0s 242us/step - loss: 373.2106 - mean_absolute_error: 16.1019 - acc: 0.0000e+00\n", + "Epoch 291/400\n", + "80/80 [==============================] - 0s 65us/step - loss: 373.1808 - mean_absolute_error: 16.1016 - acc: 0.0000e+00\n", + "Epoch 292/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 373.1518 - mean_absolute_error: 16.1012 - acc: 0.0000e+00\n", + "Epoch 293/400\n", + "80/80 [==============================] - 0s 36us/step - loss: 373.1236 - mean_absolute_error: 16.1008 - acc: 0.0000e+00\n", + "Epoch 294/400\n", + "80/80 [==============================] - 0s 61us/step - loss: 373.0963 - mean_absolute_error: 16.1004 - acc: 0.0000e+00\n", + "Epoch 295/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 373.0698 - mean_absolute_error: 16.1000 - acc: 0.0000e+00\n", + "Epoch 296/400\n", + "80/80 [==============================] - 0s 83us/step - loss: 373.0440 - mean_absolute_error: 16.0997 - acc: 0.0000e+00\n", + "Epoch 297/400\n", + "80/80 [==============================] - 0s 44us/step - loss: 373.0190 - mean_absolute_error: 16.0993 - acc: 0.0000e+00\n", + "Epoch 298/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 372.9947 - mean_absolute_error: 16.0990 - acc: 0.0000e+00\n", + "Epoch 299/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 372.9710 - mean_absolute_error: 16.0986 - acc: 0.0000e+00\n", + "Epoch 300/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 372.9481 - mean_absolute_error: 16.0983 - acc: 0.0000e+00\n", + "Epoch 301/400\n", + "80/80 [==============================] - 0s 36us/step - loss: 372.9258 - mean_absolute_error: 16.0979 - acc: 0.0000e+00\n", + "Epoch 302/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 372.9042 - mean_absolute_error: 16.0976 - acc: 0.0000e+00\n", + "Epoch 303/400\n", + "80/80 [==============================] - 0s 40us/step - loss: 372.8832 - mean_absolute_error: 16.0973 - acc: 0.0000e+00\n", + "Epoch 304/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 372.8628 - mean_absolute_error: 16.0969 - acc: 0.0000e+00\n", + "Epoch 305/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 372.8430 - mean_absolute_error: 16.0966 - acc: 0.0000e+00\n", + "Epoch 306/400\n", + "80/80 [==============================] - 0s 43us/step - loss: 372.8237 - mean_absolute_error: 16.0963 - acc: 0.0000e+00\n", + "Epoch 307/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 372.8050 - mean_absolute_error: 16.0960 - acc: 0.0000e+00\n", + "Epoch 308/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 372.7869 - mean_absolute_error: 16.0957 - acc: 0.0000e+00\n", + "Epoch 309/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 372.7693 - mean_absolute_error: 16.0954 - acc: 0.0000e+00\n", + "Epoch 310/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 372.7522 - mean_absolute_error: 16.0951 - acc: 0.0000e+00\n", + "Epoch 311/400\n", + "80/80 [==============================] - 0s 47us/step - loss: 372.7355 - mean_absolute_error: 16.0948 - acc: 0.0000e+00\n", + "Epoch 312/400\n", + "80/80 [==============================] - 0s 30us/step - loss: 372.7194 - mean_absolute_error: 16.0945 - acc: 0.0000e+00\n", + "Epoch 313/400\n", + "80/80 [==============================] - 0s 30us/step - loss: 372.7037 - mean_absolute_error: 16.0942 - acc: 0.0000e+00\n", + "Epoch 314/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 372.6886 - mean_absolute_error: 16.0939 - acc: 0.0000e+00\n", + "Epoch 315/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 372.6737 - mean_absolute_error: 16.0936 - acc: 0.0000e+00\n", + "Epoch 316/400\n", + "80/80 [==============================] - 0s 51us/step - loss: 372.6594 - mean_absolute_error: 16.0934 - acc: 0.0000e+00\n", + "Epoch 317/400\n", + "80/80 [==============================] - 0s 55us/step - loss: 372.6454 - mean_absolute_error: 16.0931 - acc: 0.0000e+00\n", + "Epoch 318/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 372.6319 - mean_absolute_error: 16.0928 - acc: 0.0000e+00\n", + "Epoch 319/400\n", + "80/80 [==============================] - 0s 40us/step - loss: 372.6187 - mean_absolute_error: 16.0926 - acc: 0.0000e+00\n", + "Epoch 320/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 372.6060 - mean_absolute_error: 16.0923 - acc: 0.0000e+00\n", + "Epoch 321/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 372.5936 - mean_absolute_error: 16.0921 - acc: 0.0000e+00\n", + "Epoch 322/400\n", + "80/80 [==============================] - 0s 28us/step - loss: 372.5815 - mean_absolute_error: 16.0918 - acc: 0.0000e+00\n", + "Epoch 323/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 372.5699 - mean_absolute_error: 16.0916 - acc: 0.0000e+00\n", + "Epoch 324/400\n", + "80/80 [==============================] - 0s 36us/step - loss: 372.5585 - mean_absolute_error: 16.0913 - acc: 0.0000e+00\n", + "Epoch 325/400\n", + "80/80 [==============================] - 0s 57us/step - loss: 372.5475 - mean_absolute_error: 16.0911 - acc: 0.0000e+00\n", + "Epoch 326/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 372.5367 - mean_absolute_error: 16.0908 - acc: 0.0000e+00\n", + "Epoch 327/400\n", + "80/80 [==============================] - 0s 29us/step - loss: 372.5263 - mean_absolute_error: 16.0906 - acc: 0.0000e+00\n", + "Epoch 328/400\n", + "80/80 [==============================] - 0s 47us/step - loss: 372.5162 - mean_absolute_error: 16.0904 - acc: 0.0000e+00\n", + "Epoch 329/400\n", + "80/80 [==============================] - 0s 33us/step - loss: 372.5064 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 330/400\n", + "80/80 [==============================] - 0s 38us/step - loss: 372.4969 - mean_absolute_error: 16.0899 - acc: 0.0000e+00\n", + "Epoch 331/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 372.4877 - mean_absolute_error: 16.0897 - acc: 0.0000e+00\n", + "Epoch 332/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 372.4786 - mean_absolute_error: 16.0895 - acc: 0.0000e+00\n", + "Epoch 333/400\n", + "80/80 [==============================] - 0s 42us/step - loss: 372.4699 - mean_absolute_error: 16.0895 - acc: 0.0000e+00\n", + "Epoch 334/400\n", + "80/80 [==============================] - 0s 37us/step - loss: 372.4615 - mean_absolute_error: 16.0895 - acc: 0.0000e+00\n", + "Epoch 335/400\n", + "80/80 [==============================] - 0s 53us/step - loss: 372.4532 - mean_absolute_error: 16.0896 - acc: 0.0000e+00\n", + "Epoch 336/400\n", + "80/80 [==============================] - 0s 42us/step - loss: 372.4452 - mean_absolute_error: 16.0896 - acc: 0.0000e+00\n", + "Epoch 337/400\n", + "80/80 [==============================] - 0s 24us/step - loss: 372.4374 - mean_absolute_error: 16.0896 - acc: 0.0000e+00\n", + "Epoch 338/400\n", + "80/80 [==============================] - 0s 36us/step - loss: 372.4299 - mean_absolute_error: 16.0896 - acc: 0.0000e+00\n", + "Epoch 339/400\n", + "80/80 [==============================] - 0s 59us/step - loss: 372.4226 - mean_absolute_error: 16.0896 - acc: 0.0000e+00\n", + "Epoch 340/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 372.4155 - mean_absolute_error: 16.0896 - acc: 0.0000e+00\n", + "Epoch 341/400\n", + "80/80 [==============================] - 0s 64us/step - loss: 372.4086 - mean_absolute_error: 16.0896 - acc: 0.0000e+00\n", + "Epoch 342/400\n", + "80/80 [==============================] - 0s 49us/step - loss: 372.4019 - mean_absolute_error: 16.0897 - acc: 0.0000e+00\n", + "Epoch 343/400\n", + "80/80 [==============================] - 0s 60us/step - loss: 372.3954 - mean_absolute_error: 16.0897 - acc: 0.0000e+00\n", + "Epoch 344/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 372.3890 - mean_absolute_error: 16.0897 - acc: 0.0000e+00\n", + "Epoch 345/400\n", + "80/80 [==============================] - 0s 23us/step - loss: 372.3829 - mean_absolute_error: 16.0897 - acc: 0.0000e+00\n", + "Epoch 346/400\n", + "80/80 [==============================] - 0s 46us/step - loss: 372.3769 - mean_absolute_error: 16.0897 - acc: 0.0000e+00\n", + "Epoch 347/400\n", + "80/80 [==============================] - 0s 46us/step - loss: 372.3712 - mean_absolute_error: 16.0897 - acc: 0.0000e+00\n", + "Epoch 348/400\n", + "80/80 [==============================] - 0s 43us/step - loss: 372.3655 - mean_absolute_error: 16.0897 - acc: 0.0000e+00\n", + "Epoch 349/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 372.3600 - mean_absolute_error: 16.0897 - acc: 0.0000e+00\n", + "Epoch 350/400\n", + "80/80 [==============================] - 0s 21us/step - loss: 372.3547 - mean_absolute_error: 16.0898 - acc: 0.0000e+00\n", + "Epoch 351/400\n", + "80/80 [==============================] - 0s 51us/step - loss: 372.3495 - mean_absolute_error: 16.0898 - acc: 0.0000e+00\n", + "Epoch 352/400\n", + "80/80 [==============================] - 0s 43us/step - loss: 372.3446 - mean_absolute_error: 16.0898 - acc: 0.0000e+00\n", + "Epoch 353/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 372.3397 - mean_absolute_error: 16.0898 - acc: 0.0000e+00\n", + "Epoch 354/400\n", + "80/80 [==============================] - 0s 39us/step - loss: 372.3350 - mean_absolute_error: 16.0898 - acc: 0.0000e+00\n", + "Epoch 355/400\n", + "80/80 [==============================] - 0s 47us/step - loss: 372.3304 - mean_absolute_error: 16.0898 - acc: 0.0000e+00\n", + "Epoch 356/400\n", + "80/80 [==============================] - 0s 39us/step - loss: 372.3260 - mean_absolute_error: 16.0898 - acc: 0.0000e+00\n", + "Epoch 357/400\n", + "80/80 [==============================] - 0s 61us/step - loss: 372.3216 - mean_absolute_error: 16.0898 - acc: 0.0000e+00\n", + "Epoch 358/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 372.3174 - mean_absolute_error: 16.0898 - acc: 0.0000e+00\n", + "Epoch 359/400\n", + "80/80 [==============================] - 0s 73us/step - loss: 372.3133 - mean_absolute_error: 16.0899 - acc: 0.0000e+00\n", + "Epoch 360/400\n", + "80/80 [==============================] - 0s 49us/step - loss: 372.3094 - mean_absolute_error: 16.0899 - acc: 0.0000e+00\n", + "Epoch 361/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 372.3056 - mean_absolute_error: 16.0899 - acc: 0.0000e+00\n", + "Epoch 362/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 372.3018 - mean_absolute_error: 16.0899 - acc: 0.0000e+00\n", + "Epoch 363/400\n", + "80/80 [==============================] - 0s 46us/step - loss: 372.2982 - mean_absolute_error: 16.0899 - acc: 0.0000e+00\n", + "Epoch 364/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 372.2946 - mean_absolute_error: 16.0899 - acc: 0.0000e+00\n", + "Epoch 365/400\n", + "80/80 [==============================] - 0s 67us/step - loss: 372.2912 - mean_absolute_error: 16.0899 - acc: 0.0000e+00\n", + "Epoch 366/400\n", + "80/80 [==============================] - 0s 42us/step - loss: 372.2879 - mean_absolute_error: 16.0899 - acc: 0.0000e+00\n", + "Epoch 367/400\n", + "80/80 [==============================] - 0s 44us/step - loss: 372.2847 - mean_absolute_error: 16.0899 - acc: 0.0000e+00\n", + "Epoch 368/400\n", + "80/80 [==============================] - 0s 108us/step - loss: 372.2816 - mean_absolute_error: 16.0899 - acc: 0.0000e+00\n", + "Epoch 369/400\n", + "80/80 [==============================] - 0s 49us/step - loss: 372.2785 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 370/400\n", + "80/80 [==============================] - 0s 70us/step - loss: 372.2756 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 371/400\n", + "80/80 [==============================] - 0s 52us/step - loss: 372.2727 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 372/400\n", + "80/80 [==============================] - 0s 44us/step - loss: 372.2699 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 373/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 372.2672 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 374/400\n", + "80/80 [==============================] - 0s 42us/step - loss: 372.2646 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 375/400\n", + "80/80 [==============================] - 0s 38us/step - loss: 372.2620 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 376/400\n", + "80/80 [==============================] - 0s 62us/step - loss: 372.2595 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 377/400\n", + "80/80 [==============================] - 0s 129us/step - loss: 372.2571 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 378/400\n", + "80/80 [==============================] - 0s 54us/step - loss: 372.2548 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 379/400\n", + "80/80 [==============================] - 0s 49us/step - loss: 372.2525 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 380/400\n", + "80/80 [==============================] - 0s 49us/step - loss: 372.2503 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 381/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 372.2481 - mean_absolute_error: 16.0900 - acc: 0.0000e+00\n", + "Epoch 382/400\n", + "80/80 [==============================] - 0s 44us/step - loss: 372.2461 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 383/400\n", + "80/80 [==============================] - 0s 27us/step - loss: 372.2441 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 384/400\n", + "80/80 [==============================] - 0s 42us/step - loss: 372.2421 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 385/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 372.2402 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 386/400\n", + "80/80 [==============================] - 0s 71us/step - loss: 372.2383 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 387/400\n", + "80/80 [==============================] - 0s 32us/step - loss: 372.2366 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 388/400\n", + "80/80 [==============================] - 0s 52us/step - loss: 372.2348 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 389/400\n", + "80/80 [==============================] - 0s 41us/step - loss: 372.2332 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 390/400\n", + "80/80 [==============================] - 0s 26us/step - loss: 372.2314 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 391/400\n", + "80/80 [==============================] - 0s 34us/step - loss: 372.2299 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 392/400\n", + "80/80 [==============================] - 0s 50us/step - loss: 372.2283 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 393/400\n", + "80/80 [==============================] - 0s 25us/step - loss: 372.2267 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 394/400\n", + "80/80 [==============================] - 0s 57us/step - loss: 372.2253 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 395/400\n", + "80/80 [==============================] - 0s 44us/step - loss: 372.2239 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 396/400\n", + "80/80 [==============================] - 0s 42us/step - loss: 372.2225 - mean_absolute_error: 16.0901 - acc: 0.0000e+00\n", + "Epoch 397/400\n", + "80/80 [==============================] - 0s 31us/step - loss: 372.2212 - mean_absolute_error: 16.0902 - acc: 0.0000e+00\n", + "Epoch 398/400\n", + "80/80 [==============================] - 0s 20us/step - loss: 372.2199 - mean_absolute_error: 16.0902 - acc: 0.0000e+00\n", + "Epoch 399/400\n", + "80/80 [==============================] - 0s 38us/step - loss: 372.2186 - mean_absolute_error: 16.0902 - acc: 0.0000e+00\n", + "Epoch 400/400\n", + "80/80 [==============================] - 0s 78us/step - loss: 372.2174 - mean_absolute_error: 16.0902 - acc: 0.0000e+00\n" + ] + } + ], + "source": [ + "history = lr3.fit(Xtrain, ytrain, epochs=400, batch_size=80)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(history.history['loss'])" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[array([[82.38442]], dtype=float32), array([-3.3930035], dtype=float32)]" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lr3.get_weights()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using the Keras Functional API\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_3 (InputLayer) (None, 1) 0 \n", + "_________________________________________________________________\n", + "dense_17 (Dense) (None, 1) 2 \n", + "=================================================================\n", + "Total params: 2\n", + "Trainable params: 2\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "from keras.layers import Input, Dense\n", + "from keras.models import Model\n", + "\n", + "inputs_placeholder = Input(shape=(1,))\n", + "outputs_placeholder = Dense(1, activation='linear')(inputs_placeholder)\n", + "\n", + "m = Model(inputs=inputs_placeholder, outputs=outputs_placeholder)\n", + "m.compile(optimizer='sgd', loss='mean_squared_error', metrics=['mae','accuracy'])\n", + "m.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/250\n", + "80/80 [==============================] - 0s 6ms/step - loss: 5279.3291 - mean_absolute_error: 59.3928 - acc: 0.0000e+00\n", + "Epoch 2/250\n", + "80/80 [==============================] - 0s 22us/step - loss: 5136.4331 - mean_absolute_error: 58.5800 - acc: 0.0000e+00\n", + "Epoch 3/250\n", + "80/80 [==============================] - 0s 21us/step - loss: 4997.7144 - mean_absolute_error: 57.7793 - acc: 0.0000e+00\n", + "Epoch 4/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 4863.0483 - mean_absolute_error: 56.9904 - acc: 0.0000e+00\n", + "Epoch 5/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 4732.3164 - mean_absolute_error: 56.2221 - acc: 0.0000e+00\n", + "Epoch 6/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 4605.4038 - mean_absolute_error: 55.4700 - acc: 0.0000e+00\n", + "Epoch 7/250\n", + "80/80 [==============================] - 0s 25us/step - loss: 4482.1968 - mean_absolute_error: 54.7378 - acc: 0.0000e+00\n", + "Epoch 8/250\n", + "80/80 [==============================] - 0s 22us/step - loss: 4362.5889 - mean_absolute_error: 54.0210 - acc: 0.0000e+00\n", + "Epoch 9/250\n", + "80/80 [==============================] - 0s 28us/step - loss: 4246.4736 - mean_absolute_error: 53.3273 - acc: 0.0000e+00\n", + "Epoch 10/250\n", + "80/80 [==============================] - 0s 37us/step - loss: 4133.7476 - mean_absolute_error: 52.6478 - acc: 0.0000e+00\n", + "Epoch 11/250\n", + "80/80 [==============================] - 0s 25us/step - loss: 4024.3125 - mean_absolute_error: 51.9782 - acc: 0.0000e+00\n", + "Epoch 12/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 3918.0710 - mean_absolute_error: 51.3186 - acc: 0.0000e+00\n", + "Epoch 13/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 3814.9304 - mean_absolute_error: 50.6686 - acc: 0.0000e+00\n", + "Epoch 14/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 3714.7996 - mean_absolute_error: 50.0283 - acc: 0.0000e+00\n", + "Epoch 15/250\n", + "80/80 [==============================] - 0s 24us/step - loss: 3617.5903 - mean_absolute_error: 49.3974 - acc: 0.0000e+00\n", + "Epoch 16/250\n", + "80/80 [==============================] - 0s 32us/step - loss: 3523.2163 - mean_absolute_error: 48.7757 - acc: 0.0000e+00\n", + "Epoch 17/250\n", + "80/80 [==============================] - 0s 37us/step - loss: 3431.5950 - mean_absolute_error: 48.1633 - acc: 0.0000e+00\n", + "Epoch 18/250\n", + "80/80 [==============================] - 0s 24us/step - loss: 3342.6460 - mean_absolute_error: 47.5598 - acc: 0.0000e+00\n", + "Epoch 19/250\n", + "80/80 [==============================] - 0s 25us/step - loss: 3256.2915 - mean_absolute_error: 46.9652 - acc: 0.0000e+00\n", + "Epoch 20/250\n", + "80/80 [==============================] - 0s 38us/step - loss: 3172.4543 - mean_absolute_error: 46.3794 - acc: 0.0000e+00\n", + "Epoch 21/250\n", + "80/80 [==============================] - 0s 40us/step - loss: 3091.0610 - mean_absolute_error: 45.8022 - acc: 0.0000e+00\n", + "Epoch 22/250\n", + "80/80 [==============================] - 0s 28us/step - loss: 3012.0410 - mean_absolute_error: 45.2336 - acc: 0.0000e+00\n", + "Epoch 23/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 2935.3240 - mean_absolute_error: 44.6732 - acc: 0.0000e+00\n", + "Epoch 24/250\n", + "80/80 [==============================] - 0s 23us/step - loss: 2860.8425 - mean_absolute_error: 44.1212 - acc: 0.0000e+00\n", + "Epoch 25/250\n", + "80/80 [==============================] - 0s 48us/step - loss: 2788.5320 - mean_absolute_error: 43.5773 - acc: 0.0000e+00\n", + "Epoch 26/250\n", + "80/80 [==============================] - 0s 41us/step - loss: 2718.3281 - mean_absolute_error: 43.0413 - acc: 0.0000e+00\n", + "Epoch 27/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 2650.1694 - mean_absolute_error: 42.5133 - acc: 0.0000e+00\n", + "Epoch 28/250\n", + "80/80 [==============================] - 0s 21us/step - loss: 2583.9966 - mean_absolute_error: 41.9930 - acc: 0.0000e+00\n", + "Epoch 29/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 2519.7510 - mean_absolute_error: 41.4804 - acc: 0.0000e+00\n", + "Epoch 30/250\n", + "80/80 [==============================] - 0s 32us/step - loss: 2457.3765 - mean_absolute_error: 40.9753 - acc: 0.0000e+00\n", + "Epoch 31/250\n", + "80/80 [==============================] - 0s 28us/step - loss: 2396.8184 - mean_absolute_error: 40.4777 - acc: 0.0000e+00\n", + "Epoch 32/250\n", + "80/80 [==============================] - 0s 24us/step - loss: 2338.0237 - mean_absolute_error: 39.9874 - acc: 0.0000e+00\n", + "Epoch 33/250\n", + "80/80 [==============================] - 0s 25us/step - loss: 2280.9407 - mean_absolute_error: 39.5043 - acc: 0.0000e+00\n", + "Epoch 34/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 2225.5195 - mean_absolute_error: 39.0283 - acc: 0.0000e+00\n", + "Epoch 35/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 2171.7117 - mean_absolute_error: 38.5593 - acc: 0.0000e+00\n", + "Epoch 36/250\n", + "80/80 [==============================] - 0s 25us/step - loss: 2119.4700 - mean_absolute_error: 38.0972 - acc: 0.0000e+00\n", + "Epoch 37/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 2068.7485 - mean_absolute_error: 37.6419 - acc: 0.0000e+00\n", + "Epoch 38/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 2019.5032 - mean_absolute_error: 37.1934 - acc: 0.0000e+00\n", + "Epoch 39/250\n", + "80/80 [==============================] - 0s 28us/step - loss: 1971.6908 - mean_absolute_error: 36.7514 - acc: 0.0000e+00\n", + "Epoch 40/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 1925.2692 - mean_absolute_error: 36.3159 - acc: 0.0000e+00\n", + "Epoch 41/250\n", + "80/80 [==============================] - 0s 23us/step - loss: 1880.1980 - mean_absolute_error: 35.8868 - acc: 0.0000e+00\n", + "Epoch 42/250\n", + "80/80 [==============================] - 0s 76us/step - loss: 1836.4381 - mean_absolute_error: 35.4640 - acc: 0.0000e+00\n", + "Epoch 43/250\n", + "80/80 [==============================] - 0s 30us/step - loss: 1793.9512 - mean_absolute_error: 35.0474 - acc: 0.0000e+00\n", + "Epoch 44/250\n", + "80/80 [==============================] - 0s 29us/step - loss: 1752.6996 - mean_absolute_error: 34.6370 - acc: 0.0000e+00\n", + "Epoch 45/250\n", + "80/80 [==============================] - 0s 31us/step - loss: 1712.6477 - mean_absolute_error: 34.2326 - acc: 0.0000e+00\n", + "Epoch 46/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 1673.7605 - mean_absolute_error: 33.8341 - acc: 0.0000e+00\n", + "Epoch 47/250\n", + "80/80 [==============================] - 0s 24us/step - loss: 1636.0037 - mean_absolute_error: 33.4415 - acc: 0.0000e+00\n", + "Epoch 48/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 1599.3445 - mean_absolute_error: 33.0614 - acc: 0.0000e+00\n", + "Epoch 49/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 1563.7513 - mean_absolute_error: 32.6921 - acc: 0.0000e+00\n", + "Epoch 50/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 1529.1927 - mean_absolute_error: 32.3294 - acc: 0.0000e+00\n", + "Epoch 51/250\n", + "80/80 [==============================] - 0s 40us/step - loss: 1495.6383 - mean_absolute_error: 31.9772 - acc: 0.0000e+00\n", + "Epoch 52/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 1463.0592 - mean_absolute_error: 31.6302 - acc: 0.0000e+00\n", + "Epoch 53/250\n", + "80/80 [==============================] - 0s 42us/step - loss: 1431.4266 - mean_absolute_error: 31.2883 - acc: 0.0000e+00\n", + "Epoch 54/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 1400.7135 - mean_absolute_error: 30.9514 - acc: 0.0000e+00\n", + "Epoch 55/250\n", + "80/80 [==============================] - 0s 25us/step - loss: 1370.8926 - mean_absolute_error: 30.6194 - acc: 0.0000e+00\n", + "Epoch 56/250\n", + "80/80 [==============================] - 0s 28us/step - loss: 1341.9381 - mean_absolute_error: 30.2923 - acc: 0.0000e+00\n", + "Epoch 57/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 1313.8248 - mean_absolute_error: 29.9700 - acc: 0.0000e+00\n", + "Epoch 58/250\n", + "80/80 [==============================] - 0s 28us/step - loss: 1286.5281 - mean_absolute_error: 29.6573 - acc: 0.0000e+00\n", + "Epoch 59/250\n", + "80/80 [==============================] - 0s 41us/step - loss: 1260.0240 - mean_absolute_error: 29.3516 - acc: 0.0000e+00\n", + "Epoch 60/250\n", + "80/80 [==============================] - 0s 31us/step - loss: 1234.2898 - mean_absolute_error: 29.0504 - acc: 0.0000e+00\n", + "Epoch 61/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 1209.3029 - mean_absolute_error: 28.7535 - acc: 0.0000e+00\n", + "Epoch 62/250\n", + "80/80 [==============================] - 0s 25us/step - loss: 1185.0417 - mean_absolute_error: 28.4610 - acc: 0.0000e+00\n", + "Epoch 63/250\n", + "80/80 [==============================] - 0s 48us/step - loss: 1161.4849 - mean_absolute_error: 28.1727 - acc: 0.0000e+00\n", + "Epoch 64/250\n", + "80/80 [==============================] - 0s 25us/step - loss: 1138.6119 - mean_absolute_error: 27.8886 - acc: 0.0000e+00\n", + "Epoch 65/250\n", + "80/80 [==============================] - 0s 43us/step - loss: 1116.4031 - mean_absolute_error: 27.6096 - acc: 0.0000e+00\n", + "Epoch 66/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 1094.8390 - mean_absolute_error: 27.3473 - acc: 0.0000e+00\n", + "Epoch 67/250\n", + "80/80 [==============================] - 0s 41us/step - loss: 1073.9008 - mean_absolute_error: 27.0894 - acc: 0.0000e+00\n", + "Epoch 68/250\n", + "80/80 [==============================] - 0s 39us/step - loss: 1053.5703 - mean_absolute_error: 26.8354 - acc: 0.0000e+00\n", + "Epoch 69/250\n", + "80/80 [==============================] - 0s 25us/step - loss: 1033.8300 - mean_absolute_error: 26.5850 - acc: 0.0000e+00\n", + "Epoch 70/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 1014.6624 - mean_absolute_error: 26.3383 - acc: 0.0000e+00\n", + "Epoch 71/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 996.0510 - mean_absolute_error: 26.0952 - acc: 0.0000e+00\n", + "Epoch 72/250\n", + "80/80 [==============================] - 0s 19us/step - loss: 977.9798 - mean_absolute_error: 25.8556 - acc: 0.0000e+00\n", + "Epoch 73/250\n", + "80/80 [==============================] - 0s 21us/step - loss: 960.4329 - mean_absolute_error: 25.6195 - acc: 0.0000e+00\n", + "Epoch 74/250\n", + "80/80 [==============================] - 0s 38us/step - loss: 943.3951 - mean_absolute_error: 25.3869 - acc: 0.0000e+00\n", + "Epoch 75/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 926.8517 - mean_absolute_error: 25.1577 - acc: 0.0000e+00\n", + "Epoch 76/250\n", + "80/80 [==============================] - 0s 45us/step - loss: 910.7880 - mean_absolute_error: 24.9349 - acc: 0.0000e+00\n", + "Epoch 77/250\n", + "80/80 [==============================] - 0s 31us/step - loss: 895.1902 - mean_absolute_error: 24.7153 - acc: 0.0000e+00\n", + "Epoch 78/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 880.0451 - mean_absolute_error: 24.4989 - acc: 0.0000e+00\n", + "Epoch 79/250\n", + "80/80 [==============================] - 0s 22us/step - loss: 865.3391 - mean_absolute_error: 24.2857 - acc: 0.0000e+00\n", + "Epoch 80/250\n", + "80/80 [==============================] - 0s 48us/step - loss: 851.0598 - mean_absolute_error: 24.0756 - acc: 0.0000e+00\n", + "Epoch 81/250\n", + "80/80 [==============================] - 0s 32us/step - loss: 837.1943 - mean_absolute_error: 23.8685 - acc: 0.0000e+00\n", + "Epoch 82/250\n", + "80/80 [==============================] - 0s 37us/step - loss: 823.7310 - mean_absolute_error: 23.6647 - acc: 0.0000e+00\n", + "Epoch 83/250\n", + "80/80 [==============================] - 0s 45us/step - loss: 810.6580 - mean_absolute_error: 23.4791 - acc: 0.0000e+00\n", + "Epoch 84/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 797.9642 - mean_absolute_error: 23.2981 - acc: 0.0000e+00\n", + "Epoch 85/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 785.6383 - mean_absolute_error: 23.1198 - acc: 0.0000e+00\n", + "Epoch 86/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 773.6697 - mean_absolute_error: 22.9441 - acc: 0.0000e+00\n", + "Epoch 87/250\n", + "80/80 [==============================] - 0s 45us/step - loss: 762.0481 - mean_absolute_error: 22.7709 - acc: 0.0000e+00\n", + "Epoch 88/250\n", + "80/80 [==============================] - 0s 24us/step - loss: 750.7635 - mean_absolute_error: 22.6003 - acc: 0.0000e+00\n", + "Epoch 89/250\n", + "80/80 [==============================] - 0s 40us/step - loss: 739.8058 - mean_absolute_error: 22.4321 - acc: 0.0000e+00\n", + "Epoch 90/250\n", + "80/80 [==============================] - 0s 44us/step - loss: 729.1658 - mean_absolute_error: 22.2664 - acc: 0.0000e+00\n", + "Epoch 91/250\n", + "80/80 [==============================] - 0s 39us/step - loss: 718.8342 - mean_absolute_error: 22.1031 - acc: 0.0000e+00\n", + "Epoch 92/250\n", + "80/80 [==============================] - 0s 170us/step - loss: 708.8019 - mean_absolute_error: 21.9422 - acc: 0.0000e+00\n", + "Epoch 93/250\n", + "80/80 [==============================] - 0s 37us/step - loss: 699.0604 - mean_absolute_error: 21.7836 - acc: 0.0000e+00\n", + "Epoch 94/250\n", + "80/80 [==============================] - 0s 43us/step - loss: 689.6012 - mean_absolute_error: 21.6273 - acc: 0.0000e+00\n", + "Epoch 95/250\n", + "80/80 [==============================] - 0s 42us/step - loss: 680.4161 - mean_absolute_error: 21.4781 - acc: 0.0000e+00\n", + "Epoch 96/250\n", + "80/80 [==============================] - 0s 38us/step - loss: 671.4971 - mean_absolute_error: 21.3377 - acc: 0.0000e+00\n", + "Epoch 97/250\n", + "80/80 [==============================] - 0s 70us/step - loss: 662.8365 - mean_absolute_error: 21.2001 - acc: 0.0000e+00\n", + "Epoch 98/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 654.4269 - mean_absolute_error: 21.0644 - acc: 0.0000e+00\n", + "Epoch 99/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 646.2609 - mean_absolute_error: 20.9307 - acc: 0.0000e+00\n", + "Epoch 100/250\n", + "80/80 [==============================] - 0s 54us/step - loss: 638.3312 - mean_absolute_error: 20.7990 - acc: 0.0000e+00\n", + "Epoch 101/250\n", + "80/80 [==============================] - 0s 30us/step - loss: 630.6315 - mean_absolute_error: 20.6691 - acc: 0.0000e+00\n", + "Epoch 102/250\n", + "80/80 [==============================] - 0s 32us/step - loss: 623.1547 - mean_absolute_error: 20.5412 - acc: 0.0000e+00\n", + "Epoch 103/250\n", + "80/80 [==============================] - 0s 35us/step - loss: 615.8947 - mean_absolute_error: 20.4170 - acc: 0.0000e+00\n", + "Epoch 104/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 608.8446 - mean_absolute_error: 20.2989 - acc: 0.0000e+00\n", + "Epoch 105/250\n", + "80/80 [==============================] - 0s 38us/step - loss: 601.9988 - mean_absolute_error: 20.1825 - acc: 0.0000e+00\n", + "Epoch 106/250\n", + "80/80 [==============================] - 0s 41us/step - loss: 595.3514 - mean_absolute_error: 20.0702 - acc: 0.0000e+00\n", + "Epoch 107/250\n", + "80/80 [==============================] - 0s 37us/step - loss: 588.8964 - mean_absolute_error: 19.9603 - acc: 0.0000e+00\n", + "Epoch 108/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 582.6282 - mean_absolute_error: 19.8519 - acc: 0.0000e+00\n", + "Epoch 109/250\n", + "80/80 [==============================] - 0s 35us/step - loss: 576.5417 - mean_absolute_error: 19.7452 - acc: 0.0000e+00\n", + "Epoch 110/250\n", + "80/80 [==============================] - 0s 48us/step - loss: 570.6313 - mean_absolute_error: 19.6400 - acc: 0.0000e+00\n", + "Epoch 111/250\n", + "80/80 [==============================] - 0s 29us/step - loss: 564.8921 - mean_absolute_error: 19.5363 - acc: 0.0000e+00\n", + "Epoch 112/250\n", + "80/80 [==============================] - 0s 84us/step - loss: 559.3188 - mean_absolute_error: 19.4341 - acc: 0.0000e+00\n", + "Epoch 113/250\n", + "80/80 [==============================] - 0s 49us/step - loss: 553.9071 - mean_absolute_error: 19.3333 - acc: 0.0000e+00\n", + "Epoch 114/250\n", + "80/80 [==============================] - 0s 101us/step - loss: 548.6520 - mean_absolute_error: 19.2340 - acc: 0.0000e+00\n", + "Epoch 115/250\n", + "80/80 [==============================] - 0s 54us/step - loss: 543.5490 - mean_absolute_error: 19.1362 - acc: 0.0000e+00\n", + "Epoch 116/250\n", + "80/80 [==============================] - 0s 25us/step - loss: 538.5938 - mean_absolute_error: 19.0439 - acc: 0.0000e+00\n", + "Epoch 117/250\n", + "80/80 [==============================] - 0s 51us/step - loss: 533.7819 - mean_absolute_error: 18.9581 - acc: 0.0000e+00\n", + "Epoch 118/250\n", + "80/80 [==============================] - 0s 37us/step - loss: 529.1094 - mean_absolute_error: 18.8736 - acc: 0.0000e+00\n", + "Epoch 119/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 524.5721 - mean_absolute_error: 18.7909 - acc: 0.0000e+00\n", + "Epoch 120/250\n", + "80/80 [==============================] - 0s 32us/step - loss: 520.1661 - mean_absolute_error: 18.7165 - acc: 0.0000e+00\n", + "Epoch 121/250\n", + "80/80 [==============================] - 0s 33us/step - loss: 515.8876 - mean_absolute_error: 18.6431 - acc: 0.0000e+00\n", + "Epoch 122/250\n", + "80/80 [==============================] - 0s 30us/step - loss: 511.7330 - mean_absolute_error: 18.5708 - acc: 0.0000e+00\n", + "Epoch 123/250\n", + "80/80 [==============================] - 0s 48us/step - loss: 507.6984 - mean_absolute_error: 18.4995 - acc: 0.0000e+00\n", + "Epoch 124/250\n", + "80/80 [==============================] - 0s 44us/step - loss: 503.7808 - mean_absolute_error: 18.4322 - acc: 0.0000e+00\n", + "Epoch 125/250\n", + "80/80 [==============================] - 0s 43us/step - loss: 499.9764 - mean_absolute_error: 18.3689 - acc: 0.0000e+00\n", + "Epoch 126/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 496.2822 - mean_absolute_error: 18.3065 - acc: 0.0000e+00\n", + "Epoch 127/250\n", + "80/80 [==============================] - 0s 42us/step - loss: 492.6948 - mean_absolute_error: 18.2450 - acc: 0.0000e+00\n", + "Epoch 128/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 489.2113 - mean_absolute_error: 18.1844 - acc: 0.0000e+00\n", + "Epoch 129/250\n", + "80/80 [==============================] - 0s 30us/step - loss: 485.8285 - mean_absolute_error: 18.1246 - acc: 0.0000e+00\n", + "Epoch 130/250\n", + "80/80 [==============================] - 0s 67us/step - loss: 482.5435 - mean_absolute_error: 18.0658 - acc: 0.0000e+00\n", + "Epoch 131/250\n", + "80/80 [==============================] - 0s 50us/step - loss: 479.3537 - mean_absolute_error: 18.0077 - acc: 0.0000e+00\n", + "Epoch 132/250\n", + "80/80 [==============================] - 0s 42us/step - loss: 476.2561 - mean_absolute_error: 17.9506 - acc: 0.0000e+00\n", + "Epoch 133/250\n", + "80/80 [==============================] - 0s 56us/step - loss: 473.2480 - mean_absolute_error: 17.8942 - acc: 0.0000e+00\n", + "Epoch 134/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 470.3271 - mean_absolute_error: 17.8387 - acc: 0.0000e+00\n", + "Epoch 135/250\n", + "80/80 [==============================] - 0s 43us/step - loss: 467.4905 - mean_absolute_error: 17.7840 - acc: 0.0000e+00\n", + "Epoch 136/250\n", + "80/80 [==============================] - 0s 59us/step - loss: 464.7360 - mean_absolute_error: 17.7301 - acc: 0.0000e+00\n", + "Epoch 137/250\n", + "80/80 [==============================] - 0s 33us/step - loss: 462.0611 - mean_absolute_error: 17.6770 - acc: 0.0000e+00\n", + "Epoch 138/250\n", + "80/80 [==============================] - 0s 46us/step - loss: 459.4637 - mean_absolute_error: 17.6272 - acc: 0.0000e+00\n", + "Epoch 139/250\n", + "80/80 [==============================] - 0s 69us/step - loss: 456.9413 - mean_absolute_error: 17.5804 - acc: 0.0000e+00\n", + "Epoch 140/250\n", + "80/80 [==============================] - 0s 31us/step - loss: 454.4919 - mean_absolute_error: 17.5343 - acc: 0.0000e+00\n", + "Epoch 141/250\n", + "80/80 [==============================] - 0s 45us/step - loss: 452.1133 - mean_absolute_error: 17.4889 - acc: 0.0000e+00\n", + "Epoch 142/250\n", + "80/80 [==============================] - 0s 29us/step - loss: 449.8036 - mean_absolute_error: 17.4442 - acc: 0.0000e+00\n", + "Epoch 143/250\n", + "80/80 [==============================] - 0s 37us/step - loss: 447.5606 - mean_absolute_error: 17.4001 - acc: 0.0000e+00\n", + "Epoch 144/250\n", + "80/80 [==============================] - 0s 74us/step - loss: 445.3824 - mean_absolute_error: 17.3586 - acc: 0.0000e+00\n", + "Epoch 145/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 443.2673 - mean_absolute_error: 17.3212 - acc: 0.0000e+00\n", + "Epoch 146/250\n", + "80/80 [==============================] - 0s 31us/step - loss: 441.2134 - mean_absolute_error: 17.2844 - acc: 0.0000e+00\n", + "Epoch 147/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 439.2188 - mean_absolute_error: 17.2481 - acc: 0.0000e+00\n", + "Epoch 148/250\n", + "80/80 [==============================] - 0s 48us/step - loss: 437.2818 - mean_absolute_error: 17.2142 - acc: 0.0000e+00\n", + "Epoch 149/250\n", + "80/80 [==============================] - 0s 24us/step - loss: 435.4009 - mean_absolute_error: 17.1831 - acc: 0.0000e+00\n", + "Epoch 150/250\n", + "80/80 [==============================] - 0s 33us/step - loss: 433.5744 - mean_absolute_error: 17.1524 - acc: 0.0000e+00\n", + "Epoch 151/250\n", + "80/80 [==============================] - 0s 29us/step - loss: 431.8007 - mean_absolute_error: 17.1222 - acc: 0.0000e+00\n", + "Epoch 152/250\n", + "80/80 [==============================] - 0s 30us/step - loss: 430.0783 - mean_absolute_error: 17.0924 - acc: 0.0000e+00\n", + "Epoch 153/250\n", + "80/80 [==============================] - 0s 59us/step - loss: 428.4056 - mean_absolute_error: 17.0631 - acc: 0.0000e+00\n", + "Epoch 154/250\n", + "80/80 [==============================] - 0s 42us/step - loss: 426.7813 - mean_absolute_error: 17.0342 - acc: 0.0000e+00\n", + "Epoch 155/250\n", + "80/80 [==============================] - 0s 49us/step - loss: 425.2039 - mean_absolute_error: 17.0057 - acc: 0.0000e+00\n", + "Epoch 156/250\n", + "80/80 [==============================] - 0s 39us/step - loss: 423.6722 - mean_absolute_error: 16.9776 - acc: 0.0000e+00\n", + "Epoch 157/250\n", + "80/80 [==============================] - 0s 39us/step - loss: 422.1847 - mean_absolute_error: 16.9500 - acc: 0.0000e+00\n", + "Epoch 158/250\n", + "80/80 [==============================] - 0s 24us/step - loss: 420.7402 - mean_absolute_error: 16.9227 - acc: 0.0000e+00\n", + "Epoch 159/250\n", + "80/80 [==============================] - 0s 46us/step - loss: 419.3375 - mean_absolute_error: 16.8959 - acc: 0.0000e+00\n", + "Epoch 160/250\n", + "80/80 [==============================] - 0s 37us/step - loss: 417.9753 - mean_absolute_error: 16.8694 - acc: 0.0000e+00\n", + "Epoch 161/250\n", + "80/80 [==============================] - 0s 31us/step - loss: 416.6524 - mean_absolute_error: 16.8433 - acc: 0.0000e+00\n", + "Epoch 162/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 415.3679 - mean_absolute_error: 16.8176 - acc: 0.0000e+00\n", + "Epoch 163/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 414.1204 - mean_absolute_error: 16.7943 - acc: 0.0000e+00\n", + "Epoch 164/250\n", + "80/80 [==============================] - 0s 25us/step - loss: 412.9090 - mean_absolute_error: 16.7714 - acc: 0.0000e+00\n", + "Epoch 165/250\n", + "80/80 [==============================] - 0s 19us/step - loss: 411.7326 - mean_absolute_error: 16.7489 - acc: 0.0000e+00\n", + "Epoch 166/250\n", + "80/80 [==============================] - 0s 28us/step - loss: 410.5902 - mean_absolute_error: 16.7268 - acc: 0.0000e+00\n", + "Epoch 167/250\n", + "80/80 [==============================] - 0s 28us/step - loss: 409.4808 - mean_absolute_error: 16.7080 - acc: 0.0000e+00\n", + "Epoch 168/250\n", + "80/80 [==============================] - 0s 53us/step - loss: 408.4034 - mean_absolute_error: 16.6907 - acc: 0.0000e+00\n", + "Epoch 169/250\n", + "80/80 [==============================] - 0s 30us/step - loss: 407.3572 - mean_absolute_error: 16.6747 - acc: 0.0000e+00\n", + "Epoch 170/250\n", + "80/80 [==============================] - 0s 44us/step - loss: 406.3413 - mean_absolute_error: 16.6588 - acc: 0.0000e+00\n", + "Epoch 171/250\n", + "80/80 [==============================] - 0s 29us/step - loss: 405.3547 - mean_absolute_error: 16.6432 - acc: 0.0000e+00\n", + "Epoch 172/250\n", + "80/80 [==============================] - 0s 35us/step - loss: 404.3966 - mean_absolute_error: 16.6297 - acc: 0.0000e+00\n", + "Epoch 173/250\n", + "80/80 [==============================] - 0s 28us/step - loss: 403.4662 - mean_absolute_error: 16.6165 - acc: 0.0000e+00\n", + "Epoch 174/250\n", + "80/80 [==============================] - 0s 29us/step - loss: 402.5626 - mean_absolute_error: 16.6035 - acc: 0.0000e+00\n", + "Epoch 175/250\n", + "80/80 [==============================] - 0s 32us/step - loss: 401.6851 - mean_absolute_error: 16.5907 - acc: 0.0000e+00\n", + "Epoch 176/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 400.8331 - mean_absolute_error: 16.5780 - acc: 0.0000e+00\n", + "Epoch 177/250\n", + "80/80 [==============================] - 0s 32us/step - loss: 400.0056 - mean_absolute_error: 16.5656 - acc: 0.0000e+00\n", + "Epoch 178/250\n", + "80/80 [==============================] - 0s 33us/step - loss: 399.2020 - mean_absolute_error: 16.5533 - acc: 0.0000e+00\n", + "Epoch 179/250\n", + "80/80 [==============================] - 0s 32us/step - loss: 398.4216 - mean_absolute_error: 16.5413 - acc: 0.0000e+00\n", + "Epoch 180/250\n", + "80/80 [==============================] - 0s 29us/step - loss: 397.6638 - mean_absolute_error: 16.5294 - acc: 0.0000e+00\n", + "Epoch 181/250\n", + "80/80 [==============================] - 0s 28us/step - loss: 396.9278 - mean_absolute_error: 16.5176 - acc: 0.0000e+00\n", + "Epoch 182/250\n", + "80/80 [==============================] - 0s 39us/step - loss: 396.2132 - mean_absolute_error: 16.5061 - acc: 0.0000e+00\n", + "Epoch 183/250\n", + "80/80 [==============================] - 0s 38us/step - loss: 395.5192 - mean_absolute_error: 16.4947 - acc: 0.0000e+00\n", + "Epoch 184/250\n", + "80/80 [==============================] - 0s 30us/step - loss: 394.8452 - mean_absolute_error: 16.4835 - acc: 0.0000e+00\n", + "Epoch 185/250\n", + "80/80 [==============================] - 0s 38us/step - loss: 394.1907 - mean_absolute_error: 16.4724 - acc: 0.0000e+00\n", + "Epoch 186/250\n", + "80/80 [==============================] - 0s 29us/step - loss: 393.5551 - mean_absolute_error: 16.4615 - acc: 0.0000e+00\n", + "Epoch 187/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 392.9379 - mean_absolute_error: 16.4508 - acc: 0.0000e+00\n", + "Epoch 188/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 392.3386 - mean_absolute_error: 16.4403 - acc: 0.0000e+00\n", + "Epoch 189/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 391.7564 - mean_absolute_error: 16.4298 - acc: 0.0000e+00\n", + "Epoch 190/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 391.1912 - mean_absolute_error: 16.4196 - acc: 0.0000e+00\n", + "Epoch 191/250\n", + "80/80 [==============================] - 0s 39us/step - loss: 390.6422 - mean_absolute_error: 16.4095 - acc: 0.0000e+00\n", + "Epoch 192/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 390.1091 - mean_absolute_error: 16.3995 - acc: 0.0000e+00\n", + "Epoch 193/250\n", + "80/80 [==============================] - 0s 28us/step - loss: 389.5914 - mean_absolute_error: 16.3897 - acc: 0.0000e+00\n", + "Epoch 194/250\n", + "80/80 [==============================] - 0s 56us/step - loss: 389.0887 - mean_absolute_error: 16.3800 - acc: 0.0000e+00\n", + "Epoch 195/250\n", + "80/80 [==============================] - 0s 37us/step - loss: 388.6004 - mean_absolute_error: 16.3705 - acc: 0.0000e+00\n", + "Epoch 196/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 388.1263 - mean_absolute_error: 16.3611 - acc: 0.0000e+00\n", + "Epoch 197/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 387.6659 - mean_absolute_error: 16.3518 - acc: 0.0000e+00\n", + "Epoch 198/250\n", + "80/80 [==============================] - 0s 23us/step - loss: 387.2187 - mean_absolute_error: 16.3427 - acc: 0.0000e+00\n", + "Epoch 199/250\n", + "80/80 [==============================] - 0s 58us/step - loss: 386.7844 - mean_absolute_error: 16.3337 - acc: 0.0000e+00\n", + "Epoch 200/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 386.3627 - mean_absolute_error: 16.3250 - acc: 0.0000e+00\n", + "Epoch 201/250\n", + "80/80 [==============================] - 0s 35us/step - loss: 385.9532 - mean_absolute_error: 16.3179 - acc: 0.0000e+00\n", + "Epoch 202/250\n", + "80/80 [==============================] - 0s 41us/step - loss: 385.5555 - mean_absolute_error: 16.3113 - acc: 0.0000e+00\n", + "Epoch 203/250\n", + "80/80 [==============================] - 0s 35us/step - loss: 385.1693 - mean_absolute_error: 16.3047 - acc: 0.0000e+00\n", + "Epoch 204/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 384.7943 - mean_absolute_error: 16.2987 - acc: 0.0000e+00\n", + "Epoch 205/250\n", + "80/80 [==============================] - 0s 26us/step - loss: 384.4301 - mean_absolute_error: 16.2937 - acc: 0.0000e+00\n", + "Epoch 206/250\n", + "80/80 [==============================] - 0s 25us/step - loss: 384.0764 - mean_absolute_error: 16.2888 - acc: 0.0000e+00\n", + "Epoch 207/250\n", + "80/80 [==============================] - 0s 32us/step - loss: 383.7329 - mean_absolute_error: 16.2840 - acc: 0.0000e+00\n", + "Epoch 208/250\n", + "80/80 [==============================] - 0s 40us/step - loss: 383.3993 - mean_absolute_error: 16.2792 - acc: 0.0000e+00\n", + "Epoch 209/250\n", + "80/80 [==============================] - 0s 40us/step - loss: 383.0754 - mean_absolute_error: 16.2745 - acc: 0.0000e+00\n", + "Epoch 210/250\n", + "80/80 [==============================] - 0s 49us/step - loss: 382.7608 - mean_absolute_error: 16.2699 - acc: 0.0000e+00\n", + "Epoch 211/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 382.4553 - mean_absolute_error: 16.2654 - acc: 0.0000e+00\n", + "Epoch 212/250\n", + "80/80 [==============================] - 0s 47us/step - loss: 382.1586 - mean_absolute_error: 16.2609 - acc: 0.0000e+00\n", + "Epoch 213/250\n", + "80/80 [==============================] - 0s 27us/step - loss: 381.8705 - mean_absolute_error: 16.2565 - acc: 0.0000e+00\n", + "Epoch 214/250\n", + "80/80 [==============================] - 0s 40us/step - loss: 381.5907 - mean_absolute_error: 16.2521 - acc: 0.0000e+00\n", + "Epoch 215/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 381.3190 - mean_absolute_error: 16.2478 - acc: 0.0000e+00\n", + "Epoch 216/250\n", + "80/80 [==============================] - 0s 100us/step - loss: 381.0552 - mean_absolute_error: 16.2436 - acc: 0.0000e+00\n", + "Epoch 217/250\n", + "80/80 [==============================] - 0s 38us/step - loss: 380.7988 - mean_absolute_error: 16.2394 - acc: 0.0000e+00\n", + "Epoch 218/250\n", + "80/80 [==============================] - 0s 29us/step - loss: 380.5500 - mean_absolute_error: 16.2353 - acc: 0.0000e+00\n", + "Epoch 219/250\n", + "80/80 [==============================] - 0s 52us/step - loss: 380.3083 - mean_absolute_error: 16.2312 - acc: 0.0000e+00\n", + "Epoch 220/250\n", + "80/80 [==============================] - 0s 42us/step - loss: 380.0736 - mean_absolute_error: 16.2272 - acc: 0.0000e+00\n", + "Epoch 221/250\n", + "80/80 [==============================] - 0s 45us/step - loss: 379.8457 - mean_absolute_error: 16.2233 - acc: 0.0000e+00\n", + "Epoch 222/250\n", + "80/80 [==============================] - 0s 38us/step - loss: 379.6244 - mean_absolute_error: 16.2194 - acc: 0.0000e+00\n", + "Epoch 223/250\n", + "80/80 [==============================] - 0s 35us/step - loss: 379.4094 - mean_absolute_error: 16.2156 - acc: 0.0000e+00\n", + "Epoch 224/250\n", + "80/80 [==============================] - 0s 48us/step - loss: 379.2007 - mean_absolute_error: 16.2118 - acc: 0.0000e+00\n", + "Epoch 225/250\n", + "80/80 [==============================] - 0s 40us/step - loss: 378.9979 - mean_absolute_error: 16.2081 - acc: 0.0000e+00\n", + "Epoch 226/250\n", + "80/80 [==============================] - 0s 28us/step - loss: 378.8011 - mean_absolute_error: 16.2044 - acc: 0.0000e+00\n", + "Epoch 227/250\n", + "80/80 [==============================] - 0s 40us/step - loss: 378.6098 - mean_absolute_error: 16.2008 - acc: 0.0000e+00\n", + "Epoch 228/250\n", + "80/80 [==============================] - 0s 45us/step - loss: 378.4242 - mean_absolute_error: 16.1973 - acc: 0.0000e+00\n", + "Epoch 229/250\n", + "80/80 [==============================] - 0s 89us/step - loss: 378.2439 - mean_absolute_error: 16.1938 - acc: 0.0000e+00\n", + "Epoch 230/250\n", + "80/80 [==============================] - 0s 31us/step - loss: 378.0688 - mean_absolute_error: 16.1903 - acc: 0.0000e+00\n", + "Epoch 231/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 377.8988 - mean_absolute_error: 16.1869 - acc: 0.0000e+00\n", + "Epoch 232/250\n", + "80/80 [==============================] - 0s 45us/step - loss: 377.7336 - mean_absolute_error: 16.1835 - acc: 0.0000e+00\n", + "Epoch 233/250\n", + "80/80 [==============================] - 0s 44us/step - loss: 377.5732 - mean_absolute_error: 16.1802 - acc: 0.0000e+00\n", + "Epoch 234/250\n", + "80/80 [==============================] - 0s 55us/step - loss: 377.4175 - mean_absolute_error: 16.1770 - acc: 0.0000e+00\n", + "Epoch 235/250\n", + "80/80 [==============================] - 0s 48us/step - loss: 377.2663 - mean_absolute_error: 16.1738 - acc: 0.0000e+00\n", + "Epoch 236/250\n", + "80/80 [==============================] - 0s 38us/step - loss: 377.1194 - mean_absolute_error: 16.1706 - acc: 0.0000e+00\n", + "Epoch 237/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 376.9767 - mean_absolute_error: 16.1675 - acc: 0.0000e+00\n", + "Epoch 238/250\n", + "80/80 [==============================] - 0s 40us/step - loss: 376.8382 - mean_absolute_error: 16.1644 - acc: 0.0000e+00\n", + "Epoch 239/250\n", + "80/80 [==============================] - 0s 23us/step - loss: 376.7037 - mean_absolute_error: 16.1614 - acc: 0.0000e+00\n", + "Epoch 240/250\n", + "80/80 [==============================] - 0s 31us/step - loss: 376.5731 - mean_absolute_error: 16.1588 - acc: 0.0000e+00\n", + "Epoch 241/250\n", + "80/80 [==============================] - 0s 29us/step - loss: 376.4462 - mean_absolute_error: 16.1571 - acc: 0.0000e+00\n", + "Epoch 242/250\n", + "80/80 [==============================] - 0s 34us/step - loss: 376.3230 - mean_absolute_error: 16.1554 - acc: 0.0000e+00\n", + "Epoch 243/250\n", + "80/80 [==============================] - 0s 29us/step - loss: 376.2034 - mean_absolute_error: 16.1537 - acc: 0.0000e+00\n", + "Epoch 244/250\n", + "80/80 [==============================] - 0s 52us/step - loss: 376.0871 - mean_absolute_error: 16.1520 - acc: 0.0000e+00\n", + "Epoch 245/250\n", + "80/80 [==============================] - 0s 50us/step - loss: 375.9743 - mean_absolute_error: 16.1504 - acc: 0.0000e+00\n", + "Epoch 246/250\n", + "80/80 [==============================] - 0s 36us/step - loss: 375.8647 - mean_absolute_error: 16.1488 - acc: 0.0000e+00\n", + "Epoch 247/250\n", + "80/80 [==============================] - 0s 64us/step - loss: 375.7582 - mean_absolute_error: 16.1472 - acc: 0.0000e+00\n", + "Epoch 248/250\n", + "80/80 [==============================] - 0s 38us/step - loss: 375.6549 - mean_absolute_error: 16.1456 - acc: 0.0000e+00\n", + "Epoch 249/250\n", + "80/80 [==============================] - 0s 48us/step - loss: 375.5545 - mean_absolute_error: 16.1441 - acc: 0.0000e+00\n", + "Epoch 250/250\n", + "80/80 [==============================] - 0s 51us/step - loss: 375.4571 - mean_absolute_error: 16.1426 - acc: 0.0000e+00\n" + ] + } + ], + "source": [ + "history2 = m.fit(Xtrain, ytrain, epochs=250, batch_size=80)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[array([[80.528725]], dtype=float32), array([-3.5062547], dtype=float32)]" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m.get_weights()" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "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.8" + }, + "nteract": { + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}