{ "cells": [ { "cell_type": "markdown", "id": "d5ebb4c0", "metadata": {}, "source": [ "\n", "" ] }, { "cell_type": "markdown", "id": "812b4e46", "metadata": {}, "source": [ "# Exercises weeks 43 and 44 \n", "**October 23-27, 2023**\n", "\n", "Date: **Deadline is Sunday November 5 at midnight**\n", "\n", "You can hand in the exercises from week 43 and week 44 as one exercise and get a total score of two additional points." ] }, { "cell_type": "markdown", "id": "3230cd2f", "metadata": {}, "source": [ "# Overarching aims of the exercises weeks 43 and 44\n", "\n", "The aim of the exercises this week and next week is to get started with writing a neural network code\n", "of relevance for project 2. \n", "\n", "During week 41 we discussed three different types of gates, the\n", "so-called XOR, the OR and the AND gates. In order to develop a code\n", "for neural networks, it can be useful to set up a simpler system with\n", "only two inputs and one output. This can make it easier to debug and\n", "study the feed forward pass and the back propagation part. In the\n", "exercise this and next week, we propose to study this system with just\n", "one hidden layer and two hidden nodes. There is only one output node\n", "and we can choose to use either a simple regression case (fitting a\n", "line) or just a binary classification case with the cross-entropy as\n", "cost function.\n", "\n", "Their inputs and outputs can be\n", "summarized using the following tables, first for the OR gate with\n", "inputs $x_1$ and $x_2$ and outputs $y$:\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
$x_1$ $x_2$ $y$
0 0 0
0 1 1
1 0 1
1 1 1
" ] }, { "cell_type": "markdown", "id": "e3617d4e", "metadata": {}, "source": [ "## The AND and XOR Gates\n", "\n", "The AND gate is defined as\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
$x_1$ $x_2$ $y$
0 0 0
0 1 0
1 0 0
1 1 1
\n", "\n", "And finally we have the XOR gate\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
$x_1$ $x_2$ $y$
0 0 0
0 1 1
1 0 1
1 1 0
" ] }, { "cell_type": "markdown", "id": "54e1e7fc", "metadata": {}, "source": [ "## Representing the Data Sets\n", "\n", "Our design matrix is defined by the input values $x_1$ and $x_2$. Since we have four possible outputs, our design matrix reads" ] }, { "cell_type": "markdown", "id": "6b3c15cb", "metadata": {}, "source": [ "$$\n", "\\boldsymbol{X}=\\begin{bmatrix} 0 & 0 \\\\\n", " 0 & 1 \\\\\n", "\t\t 1 & 0 \\\\\n", "\t\t 1 & 1 \\end{bmatrix},\n", "$$" ] }, { "cell_type": "markdown", "id": "acc25271", "metadata": {}, "source": [ "while the vector of outputs is $\\boldsymbol{y}^T=[0,1,1,0]$ for the XOR gate, $\\boldsymbol{y}^T=[0,0,0,1]$ for the AND gate and $\\boldsymbol{y}^T=[0,1,1,1]$ for the OR gate.\n", "\n", "Your tasks here are\n", "\n", "1. Set up the design matrix with the inputs as discussed above and a vector containing the output, the so-called targets. Note that the design matrix is the same for all gates. You need just to define different outputs.\n", "\n", "2. Construct a neural network with only one hidden layer and two hidden nodes using the Sigmoid function as activation function.\n", "\n", "3. Set up the output layer with only one output node and use again the Sigmoid function as activation function for the output.\n", "\n", "4. Initialize the weights and biases and perform a feed forward pass and compare the outputs with the targets.\n", "\n", "5. Set up the cost function (cross entropy for classification of binary cases).\n", "\n", "6. Calculate the gradients needed for the back propagation part.\n", "\n", "7. Use the gradients to train the network in the back propagation part. Think of using automatic differentiation.\n", "\n", "8. Train the network and study your results and compare with results obtained either with **scikit-learn** or **TensorFlow**.\n", "\n", "Everything you develop here can be used directly into the code for the project." ] }, { "cell_type": "markdown", "id": "ffe0a840", "metadata": {}, "source": [ "## Setting up dimensionalities by hand\n", "\n", "It can be useful to test the dimensionalities for the network. Let us assume we have performed an optimization for XOR gate and found that the weights for the hidden layer are given by" ] }, { "cell_type": "markdown", "id": "46abf545", "metadata": {}, "source": [ "$$\n", "\\boldsymbol{W_h}=\\begin{bmatrix} 1 & 1 \\\\\n", " 1 & 1 \\end{bmatrix},\n", "$$" ] }, { "cell_type": "markdown", "id": "86e105cc", "metadata": {}, "source": [ "Multiplying $\\boldsymbol{X}$ and $\\boldsymbol{W}$ gives" ] }, { "cell_type": "markdown", "id": "5e1d21f1", "metadata": {}, "source": [ "$$\n", "\\boldsymbol{X}{W}_h=\\begin{bmatrix} 0 & 0 \\\\\n", " 1 & 1 \\\\\n", "\t\t 1 & 1 \\\\\n", "\t\t 2 & 2 \\end{bmatrix},\n", "$$" ] }, { "cell_type": "markdown", "id": "692c6cbf", "metadata": {}, "source": [ "Assume also that the bias vector for the hidden layer is" ] }, { "cell_type": "markdown", "id": "5d81e641", "metadata": {}, "source": [ "$$\n", "\\boldsymbol{b}_h=\\begin{bmatrix} 0 \\\\\n", " -1\\end{bmatrix},\n", "$$" ] }, { "cell_type": "markdown", "id": "a42bdee4", "metadata": {}, "source": [ "Adding it gives us the input to the activation function of the hidden layer" ] }, { "cell_type": "markdown", "id": "5116b854", "metadata": {}, "source": [ "$$\n", "\\boldsymbol{z}_h=\\boldsymbol{X}\\boldsymbol{W}_h+\\boldsymbol{b}_h=\\begin{bmatrix} 0 & -1 \\\\\n", " 1 & 0 \\\\\n", "\t\t 1 & 0 \\\\\n", "\t\t 2 & 1 \\end{bmatrix},\n", "$$" ] }, { "cell_type": "markdown", "id": "8dd26d09", "metadata": {}, "source": [ "Let us then assume that our activation function is the RELU function, which simply means that we take the max of $0$ and the elements of the input argument $\\boldsymbol{z}_h$, that is we have" ] }, { "cell_type": "markdown", "id": "ebf97c03", "metadata": {}, "source": [ "$$\n", "\\boldsymbol{a}_h=\\mathrm{RELU}(\\boldsymbol{z}_h=\\boldsymbol{X}\\boldsymbol{W}_h+\\boldsymbol{b}_h)=\\begin{bmatrix} 0 & 0 \\\\\n", " 1 & 0 \\\\\n", "\t\t 1 & 0 \\\\\n", "\t\t 2 & 1 \\end{bmatrix},\n", "$$" ] }, { "cell_type": "markdown", "id": "262a4a3a", "metadata": {}, "source": [ "Assume also that the bias of the output layer is zero and that the weights of the output layer are" ] }, { "cell_type": "markdown", "id": "f03ad8e7", "metadata": {}, "source": [ "$$\n", "\\boldsymbol{w}_o=\\begin{bmatrix} 1 \\\\\n", " -2\\end{bmatrix},\n", "$$" ] }, { "cell_type": "markdown", "id": "36fe00c0", "metadata": {}, "source": [ "and multiplying with $\\boldsymbol{a}_h$ gives the output" ] }, { "cell_type": "markdown", "id": "80ab43ac", "metadata": {}, "source": [ "$$\n", "\\boldsymbol{a}_o=\\begin{bmatrix} 0 & 0 \\\\\n", " 1 & 0 \\\\\n", "\t\t 1 & 0 \\\\\n", "\t\t 2 & 1 \\end{bmatrix}\\begin{bmatrix} 1 \\\\\n", " -2\\end{bmatrix}=\\begin{bmatrix} 0 \\\\ 1 \\\\ 1 \\\\0\\end{bmatrix},\n", "$$" ] }, { "cell_type": "markdown", "id": "86bcfe49", "metadata": {}, "source": [ "the wanted result. Pay attention to the dimensionalities as well." ] }, { "cell_type": "markdown", "id": "f19a899e", "metadata": {}, "source": [ "## Setting up the Neural Network\n", "\n", "We define first our design matrix and the various output vectors for the different gates." ] }, { "cell_type": "code", "execution_count": 1, "id": "901ddca7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[0.61238907]\n", " [0.61939429]\n", " [0.73482109]\n", " [0.70115106]]\n" ] } ], "source": [ "%matplotlib inline\n", "\n", "\"\"\"\n", "Simple code that tests XOR, OR and AND gates with linear regression\n", "\"\"\"\n", "\n", "# import necessary packages\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from sklearn import datasets\n", "\n", "def sigmoid(x):\n", " return 1/(1 + np.exp(-x))\n", "\n", "def feed_forward(X):\n", " # weighted sum of inputs to the hidden layer\n", " z_h = np.matmul(X, hidden_weights) + hidden_bias\n", " # activation in the hidden layer\n", " a_h = sigmoid(z_h)\n", " \n", " # weighted sum of inputs to the output layer\n", " z_o = np.matmul(a_h, output_weights) + output_bias\n", " # softmax output\n", " # axis 0 holds each input and axis 1 the probabilities of each category\n", " probabilities = sigmoid(z_o)\n", " return probabilities\n", "\n", "\n", "# ensure the same random numbers appear every time\n", "np.random.seed(0)\n", "\n", "# Design matrix\n", "X = np.array([ [0, 0], [0, 1], [1, 0],[1, 1]],dtype=np.float64)\n", "\n", "# The XOR gate\n", "yXOR = np.array( [ 0, 1 ,1, 0])\n", "# The OR gate\n", "yOR = np.array( [ 0, 1 ,1, 1])\n", "# The AND gate\n", "yAND = np.array( [ 0, 0 ,0, 1])\n", "\n", "# Defining the neural network\n", "n_inputs, n_features = X.shape\n", "n_hidden_neurons = 2\n", "n_categories = 1\n", "n_features = 2\n", "\n", "# we make the weights normally distributed using numpy.random.randn\n", "\n", "# weights and bias in the hidden layer\n", "hidden_weights = np.random.randn(n_features, n_hidden_neurons)\n", "hidden_bias = np.zeros(n_hidden_neurons) + 0.01\n", "\n", "# weights and bias in the output layer\n", "output_weights = np.random.randn(n_hidden_neurons, n_categories)\n", "output_bias = np.zeros(n_categories) + 0.01\n", "\n", "probabilities = feed_forward(X)\n", "print(probabilities)" ] }, { "cell_type": "markdown", "id": "53f22266", "metadata": {}, "source": [ "Not an impressive result, but this was our first forward pass with randomly assigned weights. Let us now add the full network with the back-propagation algorithm discussed above." ] }, { "cell_type": "markdown", "id": "5f665ac6", "metadata": {}, "source": [ "## The Code using Scikit-Learn" ] }, { "cell_type": "code", "execution_count": 2, "id": "cb396cda", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Learning rate = 1e-05\n", "Lambda = 1e-05\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 1e-05\n", "Lambda = 0.0001\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 1e-05\n", "Lambda = 0.001\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 1e-05\n", "Lambda = 0.01\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 1e-05\n", "Lambda = 0.1\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 1e-05\n", "Lambda = 1.0\n", "Accuracy score on data set: 0.5\n", "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Learning rate = 1e-05\n", "Lambda = 10.0\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.0001\n", "Lambda = 1e-05\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.0001\n", "Lambda = 0.0001\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.0001\n", "Lambda = 0.001\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.0001\n", "Lambda = 0.01\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.0001\n", "Lambda = 0.1\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.0001\n", "Lambda = 1.0\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.0001\n", "Lambda = 10.0\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.001\n", "Lambda = 1e-05\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.001\n", "Lambda = 0.0001\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.001\n", "Lambda = 0.001\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.001\n", "Lambda = 0.01\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.001\n", "Lambda = 0.1\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.001\n", "Lambda = 1.0\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.001\n", "Lambda = 10.0\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.01\n", "Lambda = 1e-05\n", "Accuracy score on data set: 0.25\n", "\n", "Learning rate = 0.01\n", "Lambda = 0.0001\n", "Accuracy score on data set: 0.75\n", "\n", "Learning rate = 0.01\n", "Lambda = 0.001\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.01\n", "Lambda = 0.01\n", "Accuracy score on data set: 0.75\n", "\n", "Learning rate = 0.01\n", "Lambda = 0.1\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.01\n", "Lambda = 1.0\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.01\n", "Lambda = 10.0\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.1\n", "Lambda = 1e-05\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.1\n", "Lambda = 0.0001\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.1\n", "Lambda = 0.001\n", "Accuracy score on data set: 1.0\n", "\n", "Learning rate = 0.1\n", "Lambda = 0.01\n", "Accuracy score on data set: 1.0\n", "\n", "Learning rate = 0.1\n", "Lambda = 0.1\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.1\n", "Lambda = 1.0\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 0.1\n", "Lambda = 10.0\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 1.0\n", "Lambda = 1e-05\n", "Accuracy score on data set: 0.75\n", "\n", "Learning rate = 1.0\n", "Lambda = 0.0001\n", "Accuracy score on data set: 0.75\n", "\n", "Learning rate = 1.0\n", "Lambda = 0.001\n", "Accuracy score on data set: 0.75\n", "\n", "Learning rate = 1.0\n", "Lambda = 0.01\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 1.0\n", "Lambda = 0.1\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 1.0\n", "Lambda = 1.0\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 1.0\n", "Lambda = 10.0\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 10.0\n", "Lambda = 1e-05\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 10.0\n", "Lambda = 0.0001\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 10.0\n", "Lambda = 0.001\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 10.0\n", "Lambda = 0.01\n", "Accuracy score on data set: 0.5\n", "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Learning rate = 10.0\n", "Lambda = 0.1\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 10.0\n", "Lambda = 1.0\n", "Accuracy score on data set: 0.5\n", "\n", "Learning rate = 10.0\n", "Lambda = 10.0\n", "Accuracy score on data set: 0.5\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n", " warnings.warn(\n", "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n", " warnings.warn(\n", "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n", " warnings.warn(\n", "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n", " warnings.warn(\n", "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n", " warnings.warn(\n", "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n", " warnings.warn(\n", "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n", " warnings.warn(\n", "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n", " warnings.warn(\n", "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n", " warnings.warn(\n", "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n", " warnings.warn(\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "filenames": { "image/png": "/Users/mhjensen/Teaching/MachineLearning/doc/LectureNotes/_build/jupyter_execute/exercisesweek43_26_4.png" } }, "output_type": "display_data" } ], "source": [ "# import necessary packages\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from sklearn.neural_network import MLPClassifier\n", "from sklearn.metrics import accuracy_score\n", "import seaborn as sns\n", "\n", "# ensure the same random numbers appear every time\n", "np.random.seed(0)\n", "\n", "# Design matrix\n", "X = np.array([ [0, 0], [0, 1], [1, 0],[1, 1]],dtype=np.float64)\n", "\n", "# The XOR gate\n", "yXOR = np.array( [ 0, 1 ,1, 0])\n", "# The OR gate\n", "yOR = np.array( [ 0, 1 ,1, 1])\n", "# The AND gate\n", "yAND = np.array( [ 0, 0 ,0, 1])\n", "\n", "# Defining the neural network\n", "n_hidden_neurons = 2\n", "\n", "eta_vals = np.logspace(-5, 1, 7)\n", "lmbd_vals = np.logspace(-5, 1, 7)\n", "# store models for later use\n", "DNN_scikit = np.zeros((len(eta_vals), len(lmbd_vals)), dtype=object)\n", "epochs = 100\n", "\n", "for i, eta in enumerate(eta_vals):\n", " for j, lmbd in enumerate(lmbd_vals):\n", " dnn = MLPClassifier(hidden_layer_sizes=(n_hidden_neurons), activation='logistic',\n", " alpha=lmbd, learning_rate_init=eta, max_iter=epochs)\n", " dnn.fit(X, yXOR)\n", " DNN_scikit[i][j] = dnn\n", " print(\"Learning rate = \", eta)\n", " print(\"Lambda = \", lmbd)\n", " print(\"Accuracy score on data set: \", dnn.score(X, yXOR))\n", " print()\n", "\n", "sns.set()\n", "test_accuracy = np.zeros((len(eta_vals), len(lmbd_vals)))\n", "for i in range(len(eta_vals)):\n", " for j in range(len(lmbd_vals)):\n", " dnn = DNN_scikit[i][j]\n", " test_pred = dnn.predict(X)\n", " test_accuracy[i][j] = accuracy_score(yXOR, test_pred)\n", "\n", "fig, ax = plt.subplots(figsize = (10, 10))\n", "sns.heatmap(test_accuracy, annot=True, ax=ax, cmap=\"viridis\")\n", "ax.set_title(\"Test Accuracy\")\n", "ax.set_ylabel(\"$\\eta$\")\n", "ax.set_xlabel(\"$\\lambda$\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "c5978471", "metadata": {}, "source": [ "## Building a neural network code\n", "\n", "Here we present a flexible object oriented codebase\n", "for a feed forward neural network, along with a demonstration of how\n", "to use it. Before we get into the details of the neural network, we\n", "will first present some implementations of various schedulers, cost\n", "functions and activation functions that can be used together with the\n", "neural network.\n", "\n", "The codes here were developed by Eric Reber and Gregor Kajda during spring 2023." ] }, { "cell_type": "markdown", "id": "7b82dc46", "metadata": {}, "source": [ "### Learning rate methods\n", "\n", "The code below shows object oriented implementations of the Constant,\n", "Momentum, Adagrad, AdagradMomentum, RMS prop and Adam schedulers. All\n", "of the classes belong to the shared abstract Scheduler class, and\n", "share the update_change() and reset() methods allowing for any of the\n", "schedulers to be seamlessly used during the training stage, as will\n", "later be shown in the fit() method of the neural\n", "network. Update_change() only has one parameter, the gradient\n", "($δ^l_ja^{l−1}_k$), and returns the change which will be subtracted\n", "from the weights. The reset() function takes no parameters, and resets\n", "the desired variables. For Constant and Momentum, reset does nothing." ] }, { "cell_type": "code", "execution_count": 3, "id": "de4dedfb", "metadata": {}, "outputs": [], "source": [ "import autograd.numpy as np\n", "\n", "class Scheduler:\n", " \"\"\"\n", " Abstract class for Schedulers\n", " \"\"\"\n", "\n", " def __init__(self, eta):\n", " self.eta = eta\n", "\n", " # should be overwritten\n", " def update_change(self, gradient):\n", " raise NotImplementedError\n", "\n", " # overwritten if needed\n", " def reset(self):\n", " pass\n", "\n", "\n", "class Constant(Scheduler):\n", " def __init__(self, eta):\n", " super().__init__(eta)\n", "\n", " def update_change(self, gradient):\n", " return self.eta * gradient\n", " \n", " def reset(self):\n", " pass\n", "\n", "\n", "class Momentum(Scheduler):\n", " def __init__(self, eta: float, momentum: float):\n", " super().__init__(eta)\n", " self.momentum = momentum\n", " self.change = 0\n", "\n", " def update_change(self, gradient):\n", " self.change = self.momentum * self.change + self.eta * gradient\n", " return self.change\n", "\n", " def reset(self):\n", " pass\n", "\n", "\n", "class Adagrad(Scheduler):\n", " def __init__(self, eta):\n", " super().__init__(eta)\n", " self.G_t = None\n", "\n", " def update_change(self, gradient):\n", " delta = 1e-8 # avoid division ny zero\n", "\n", " if self.G_t is None:\n", " self.G_t = np.zeros((gradient.shape[0], gradient.shape[0]))\n", "\n", " self.G_t += gradient @ gradient.T\n", "\n", " G_t_inverse = 1 / (\n", " delta + np.sqrt(np.reshape(np.diagonal(self.G_t), (self.G_t.shape[0], 1)))\n", " )\n", " return self.eta * gradient * G_t_inverse\n", "\n", " def reset(self):\n", " self.G_t = None\n", "\n", "\n", "class AdagradMomentum(Scheduler):\n", " def __init__(self, eta, momentum):\n", " super().__init__(eta)\n", " self.G_t = None\n", " self.momentum = momentum\n", " self.change = 0\n", "\n", " def update_change(self, gradient):\n", " delta = 1e-8 # avoid division ny zero\n", "\n", " if self.G_t is None:\n", " self.G_t = np.zeros((gradient.shape[0], gradient.shape[0]))\n", "\n", " self.G_t += gradient @ gradient.T\n", "\n", " G_t_inverse = 1 / (\n", " delta + np.sqrt(np.reshape(np.diagonal(self.G_t), (self.G_t.shape[0], 1)))\n", " )\n", " self.change = self.change * self.momentum + self.eta * gradient * G_t_inverse\n", " return self.change\n", "\n", " def reset(self):\n", " self.G_t = None\n", "\n", "\n", "class RMS_prop(Scheduler):\n", " def __init__(self, eta, rho):\n", " super().__init__(eta)\n", " self.rho = rho\n", " self.second = 0.0\n", "\n", " def update_change(self, gradient):\n", " delta = 1e-8 # avoid division ny zero\n", " self.second = self.rho * self.second + (1 - self.rho) * gradient * gradient\n", " return self.eta * gradient / (np.sqrt(self.second + delta))\n", "\n", " def reset(self):\n", " self.second = 0.0\n", "\n", "\n", "class Adam(Scheduler):\n", " def __init__(self, eta, rho, rho2):\n", " super().__init__(eta)\n", " self.rho = rho\n", " self.rho2 = rho2\n", " self.moment = 0\n", " self.second = 0\n", " self.n_epochs = 1\n", "\n", " def update_change(self, gradient):\n", " delta = 1e-8 # avoid division ny zero\n", "\n", " self.moment = self.rho * self.moment + (1 - self.rho) * gradient\n", " self.second = self.rho2 * self.second + (1 - self.rho2) * gradient * gradient\n", "\n", " moment_corrected = self.moment / (1 - self.rho**self.n_epochs)\n", " second_corrected = self.second / (1 - self.rho2**self.n_epochs)\n", "\n", " return self.eta * moment_corrected / (np.sqrt(second_corrected + delta))\n", "\n", " def reset(self):\n", " self.n_epochs += 1\n", " self.moment = 0\n", " self.second = 0" ] }, { "cell_type": "markdown", "id": "bb621fce", "metadata": {}, "source": [ "### Usage of the above learning rate schedulers\n", "\n", "To initalize a scheduler, simply create the object and pass in the\n", "necessary parameters such as the learning rate and the momentum as\n", "shown below. As the Scheduler class is an abstract class it should not\n", "called directly, and will raise an error upon usage." ] }, { "cell_type": "code", "execution_count": 4, "id": "34ddb829", "metadata": {}, "outputs": [], "source": [ "momentum_scheduler = Momentum(eta=1e-3, momentum=0.9)\n", "adam_scheduler = Adam(eta=1e-3, rho=0.9, rho2=0.999)" ] }, { "cell_type": "markdown", "id": "e43498d4", "metadata": {}, "source": [ "Here is a small example for how a segment of code using schedulers\n", "could look. Switching out the schedulers is simple." ] }, { "cell_type": "code", "execution_count": 5, "id": "f05b9625", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Before scheduler:\n", "weights=array([[1., 1., 1.],\n", " [1., 1., 1.],\n", " [1., 1., 1.]])\n", "\n", "After scheduler:\n", "weights=array([[0.993993 , 0.993993 , 0.99399301],\n", " [0.99399308, 0.99399315, 0.99399301],\n", " [0.99399301, 0.99399309, 0.99399301]])\n" ] } ], "source": [ "weights = np.ones((3,3))\n", "print(f\"Before scheduler:\\n{weights=}\")\n", "\n", "epochs = 10\n", "for e in range(epochs):\n", " gradient = np.random.rand(3, 3)\n", " change = adam_scheduler.update_change(gradient)\n", " weights = weights - change\n", " adam_scheduler.reset()\n", "\n", "print(f\"\\nAfter scheduler:\\n{weights=}\")" ] }, { "cell_type": "markdown", "id": "19cf9841", "metadata": {}, "source": [ "### Cost functions\n", "\n", "Here we discuss cost functions that can be used when creating the\n", "neural network. Every cost function takes the target vector as its\n", "parameter, and returns a function valued only at $x$ such that it may\n", "easily be differentiated." ] }, { "cell_type": "code", "execution_count": 6, "id": "993efa8d", "metadata": {}, "outputs": [], "source": [ "import autograd.numpy as np\n", "\n", "def CostOLS(target):\n", " \n", " def func(X):\n", " return (1.0 / target.shape[0]) * np.sum((target - X) ** 2)\n", "\n", " return func\n", "\n", "\n", "def CostLogReg(target):\n", "\n", " def func(X):\n", " \n", " return -(1.0 / target.shape[0]) * np.sum(\n", " (target * np.log(X + 10e-10)) + ((1 - target) * np.log(1 - X + 10e-10))\n", " )\n", "\n", " return func\n", "\n", "\n", "def CostCrossEntropy(target):\n", " \n", " def func(X):\n", " return -(1.0 / target.size) * np.sum(target * np.log(X + 10e-10))\n", "\n", " return func" ] }, { "cell_type": "markdown", "id": "011c734c", "metadata": {}, "source": [ "Below we give a short example of how these cost function may be used\n", "to obtain results if you wish to test them out on your own using\n", "AutoGrad's automatics differentiation." ] }, { "cell_type": "code", "execution_count": 7, "id": "9e1b97f5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Derivative of cost function CostCrossEntropy valued at a:\n", "[[-0.08333333]\n", " [-0.13333333]\n", " [-0.16666667]]\n" ] } ], "source": [ "from autograd import grad\n", "\n", "target = np.array([[1, 2, 3]]).T\n", "a = np.array([[4, 5, 6]]).T\n", "\n", "cost_func = CostCrossEntropy\n", "cost_func_derivative = grad(cost_func(target))\n", "\n", "valued_at_a = cost_func_derivative(a)\n", "print(f\"Derivative of cost function {cost_func.__name__} valued at a:\\n{valued_at_a}\")" ] }, { "cell_type": "markdown", "id": "4acd87b2", "metadata": {}, "source": [ "### Activation functions\n", "\n", "Finally, before we look at the neural network, we will look at the\n", "activation functions which can be specified between the hidden layers\n", "and as the output function. Each function can be valued for any given\n", "vector or matrix X, and can be differentiated via derivate()." ] }, { "cell_type": "code", "execution_count": 8, "id": "befa86ae", "metadata": {}, "outputs": [], "source": [ "import autograd.numpy as np\n", "from autograd import elementwise_grad\n", "\n", "def identity(X):\n", " return X\n", "\n", "\n", "def sigmoid(X):\n", " try:\n", " return 1.0 / (1 + np.exp(-X))\n", " except FloatingPointError:\n", " return np.where(X > np.zeros(X.shape), np.ones(X.shape), np.zeros(X.shape))\n", "\n", "\n", "def softmax(X):\n", " X = X - np.max(X, axis=-1, keepdims=True)\n", " delta = 10e-10\n", " return np.exp(X) / (np.sum(np.exp(X), axis=-1, keepdims=True) + delta)\n", "\n", "\n", "def RELU(X):\n", " return np.where(X > np.zeros(X.shape), X, np.zeros(X.shape))\n", "\n", "\n", "def LRELU(X):\n", " delta = 10e-4\n", " return np.where(X > np.zeros(X.shape), X, delta * X)\n", "\n", "\n", "def derivate(func):\n", " if func.__name__ == \"RELU\":\n", "\n", " def func(X):\n", " return np.where(X > 0, 1, 0)\n", "\n", " return func\n", "\n", " elif func.__name__ == \"LRELU\":\n", "\n", " def func(X):\n", " delta = 10e-4\n", " return np.where(X > 0, 1, delta)\n", "\n", " return func\n", "\n", " else:\n", " return elementwise_grad(func)" ] }, { "cell_type": "markdown", "id": "c20aa75e", "metadata": {}, "source": [ "Below follows a short demonstration of how to use an activation\n", "function. The derivative of the activation function will be important\n", "when calculating the output delta term during backpropagation. Note\n", "that derivate() can also be used for cost functions for a more\n", "generalized approach." ] }, { "cell_type": "code", "execution_count": 9, "id": "e209f9e5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Input to activation function:\n", "[[4]\n", " [5]\n", " [6]]\n", "\n", "Output from sigmoid activation function:\n", "[[0.98201379]\n", " [0.99330715]\n", " [0.99752738]]\n", "\n", "Derivative of sigmoid activation function valued at z:\n", "[[0.19824029]\n", " [0.19721923]\n", " [0.19683648]]\n" ] } ], "source": [ "z = np.array([[4, 5, 6]]).T\n", "print(f\"Input to activation function:\\n{z}\")\n", "\n", "act_func = sigmoid\n", "a = act_func(z)\n", "print(f\"\\nOutput from {act_func.__name__} activation function:\\n{a}\")\n", "\n", "act_func_derivative = derivate(act_func)\n", "valued_at_z = act_func_derivative(a)\n", "print(f\"\\nDerivative of {act_func.__name__} activation function valued at z:\\n{valued_at_z}\")" ] }, { "cell_type": "markdown", "id": "524b409b", "metadata": {}, "source": [ "### The Neural Network\n", "\n", "Now that we have gotten a good understanding of the implementation of\n", "some important components, we can take a look at an object oriented\n", "implementation of a feed forward neural network. The feed forward\n", "neural network has been implemented as a class named FFNN, which can\n", "be initiated as a regressor or classifier dependant on the choice of\n", "cost function. The FFNN can have any number of input nodes, hidden\n", "layers with any amount of hidden nodes, and any amount of output nodes\n", "meaning it can perform multiclass classification as well as binary\n", "classification and regression problems. Although there is a lot of\n", "code present, it makes for an easy to use and generalizeable interface\n", "for creating many types of neural networks as will be demonstrated\n", "below." ] }, { "cell_type": "code", "execution_count": 10, "id": "083116d3", "metadata": {}, "outputs": [], "source": [ "import math\n", "import autograd.numpy as np\n", "import sys\n", "import warnings\n", "from autograd import grad, elementwise_grad\n", "from random import random, seed\n", "from copy import deepcopy, copy\n", "from typing import Tuple, Callable\n", "from sklearn.utils import resample\n", "\n", "warnings.simplefilter(\"error\")\n", "\n", "\n", "class FFNN:\n", " \"\"\"\n", " Description:\n", " ------------\n", " Feed Forward Neural Network with interface enabling flexible design of a\n", " nerual networks architecture and the specification of activation function\n", " in the hidden layers and output layer respectively. This model can be used\n", " for both regression and classification problems, depending on the output function.\n", "\n", " Attributes:\n", " ------------\n", " I dimensions (tuple[int]): A list of positive integers, which specifies the\n", " number of nodes in each of the networks layers. The first integer in the array\n", " defines the number of nodes in the input layer, the second integer defines number\n", " of nodes in the first hidden layer and so on until the last number, which\n", " specifies the number of nodes in the output layer.\n", " II hidden_func (Callable): The activation function for the hidden layers\n", " III output_func (Callable): The activation function for the output layer\n", " IV cost_func (Callable): Our cost function\n", " V seed (int): Sets random seed, makes results reproducible\n", " \"\"\"\n", "\n", " def __init__(\n", " self,\n", " dimensions: tuple[int],\n", " hidden_func: Callable = sigmoid,\n", " output_func: Callable = lambda x: x,\n", " cost_func: Callable = CostOLS,\n", " seed: int = None,\n", " ):\n", " self.dimensions = dimensions\n", " self.hidden_func = hidden_func\n", " self.output_func = output_func\n", " self.cost_func = cost_func\n", " self.seed = seed\n", " self.weights = list()\n", " self.schedulers_weight = list()\n", " self.schedulers_bias = list()\n", " self.a_matrices = list()\n", " self.z_matrices = list()\n", " self.classification = None\n", "\n", " self.reset_weights()\n", " self._set_classification()\n", "\n", " def fit(\n", " self,\n", " X: np.ndarray,\n", " t: np.ndarray,\n", " scheduler: Scheduler,\n", " batches: int = 1,\n", " epochs: int = 100,\n", " lam: float = 0,\n", " X_val: np.ndarray = None,\n", " t_val: np.ndarray = None,\n", " ):\n", " \"\"\"\n", " Description:\n", " ------------\n", " This function performs the training the neural network by performing the feedforward and backpropagation\n", " algorithm to update the networks weights.\n", "\n", " Parameters:\n", " ------------\n", " I X (np.ndarray) : training data\n", " II t (np.ndarray) : target data\n", " III scheduler (Scheduler) : specified scheduler (algorithm for optimization of gradient descent)\n", " IV scheduler_args (list[int]) : list of all arguments necessary for scheduler\n", "\n", " Optional Parameters:\n", " ------------\n", " V batches (int) : number of batches the datasets are split into, default equal to 1\n", " VI epochs (int) : number of iterations used to train the network, default equal to 100\n", " VII lam (float) : regularization hyperparameter lambda\n", " VIII X_val (np.ndarray) : validation set\n", " IX t_val (np.ndarray) : validation target set\n", "\n", " Returns:\n", " ------------\n", " I scores (dict) : A dictionary containing the performance metrics of the model.\n", " The number of the metrics depends on the parameters passed to the fit-function.\n", "\n", " \"\"\"\n", "\n", " # setup \n", " if self.seed is not None:\n", " np.random.seed(self.seed)\n", "\n", " val_set = False\n", " if X_val is not None and t_val is not None:\n", " val_set = True\n", "\n", " # creating arrays for score metrics\n", " train_errors = np.empty(epochs)\n", " train_errors.fill(np.nan)\n", " val_errors = np.empty(epochs)\n", " val_errors.fill(np.nan)\n", "\n", " train_accs = np.empty(epochs)\n", " train_accs.fill(np.nan)\n", " val_accs = np.empty(epochs)\n", " val_accs.fill(np.nan)\n", "\n", " self.schedulers_weight = list()\n", " self.schedulers_bias = list()\n", "\n", " batch_size = X.shape[0] // batches\n", "\n", " X, t = resample(X, t)\n", "\n", " # this function returns a function valued only at X\n", " cost_function_train = self.cost_func(t)\n", " if val_set:\n", " cost_function_val = self.cost_func(t_val)\n", "\n", " # create schedulers for each weight matrix\n", " for i in range(len(self.weights)):\n", " self.schedulers_weight.append(copy(scheduler))\n", " self.schedulers_bias.append(copy(scheduler))\n", "\n", " print(f\"{scheduler.__class__.__name__}: Eta={scheduler.eta}, Lambda={lam}\")\n", "\n", " try:\n", " for e in range(epochs):\n", " for i in range(batches):\n", " # allows for minibatch gradient descent\n", " if i == batches - 1:\n", " # If the for loop has reached the last batch, take all thats left\n", " X_batch = X[i * batch_size :, :]\n", " t_batch = t[i * batch_size :, :]\n", " else:\n", " X_batch = X[i * batch_size : (i + 1) * batch_size, :]\n", " t_batch = t[i * batch_size : (i + 1) * batch_size, :]\n", "\n", " self._feedforward(X_batch)\n", " self._backpropagate(X_batch, t_batch, lam)\n", "\n", " # reset schedulers for each epoch (some schedulers pass in this call)\n", " for scheduler in self.schedulers_weight:\n", " scheduler.reset()\n", "\n", " for scheduler in self.schedulers_bias:\n", " scheduler.reset()\n", "\n", " # computing performance metrics\n", " pred_train = self.predict(X)\n", " train_error = cost_function_train(pred_train)\n", "\n", " train_errors[e] = train_error\n", " if val_set:\n", " \n", " pred_val = self.predict(X_val)\n", " val_error = cost_function_val(pred_val)\n", " val_errors[e] = val_error\n", "\n", " if self.classification:\n", " train_acc = self._accuracy(self.predict(X), t)\n", " train_accs[e] = train_acc\n", " if val_set:\n", " val_acc = self._accuracy(pred_val, t_val)\n", " val_accs[e] = val_acc\n", "\n", " # printing progress bar\n", " progression = e / epochs\n", " print_length = self._progress_bar(\n", " progression,\n", " train_error=train_errors[e],\n", " train_acc=train_accs[e],\n", " val_error=val_errors[e],\n", " val_acc=val_accs[e],\n", " )\n", " except KeyboardInterrupt:\n", " # allows for stopping training at any point and seeing the result\n", " pass\n", "\n", " # visualization of training progression (similiar to tensorflow progression bar)\n", " sys.stdout.write(\"\\r\" + \" \" * print_length)\n", " sys.stdout.flush()\n", " self._progress_bar(\n", " 1,\n", " train_error=train_errors[e],\n", " train_acc=train_accs[e],\n", " val_error=val_errors[e],\n", " val_acc=val_accs[e],\n", " )\n", " sys.stdout.write(\"\")\n", "\n", " # return performance metrics for the entire run\n", " scores = dict()\n", "\n", " scores[\"train_errors\"] = train_errors\n", "\n", " if val_set:\n", " scores[\"val_errors\"] = val_errors\n", "\n", " if self.classification:\n", " scores[\"train_accs\"] = train_accs\n", "\n", " if val_set:\n", " scores[\"val_accs\"] = val_accs\n", "\n", " return scores\n", "\n", " def predict(self, X: np.ndarray, *, threshold=0.5):\n", " \"\"\"\n", " Description:\n", " ------------\n", " Performs prediction after training of the network has been finished.\n", "\n", " Parameters:\n", " ------------\n", " I X (np.ndarray): The design matrix, with n rows of p features each\n", "\n", " Optional Parameters:\n", " ------------\n", " II threshold (float) : sets minimal value for a prediction to be predicted as the positive class\n", " in classification problems\n", "\n", " Returns:\n", " ------------\n", " I z (np.ndarray): A prediction vector (row) for each row in our design matrix\n", " This vector is thresholded if regression=False, meaning that classification results\n", " in a vector of 1s and 0s, while regressions in an array of decimal numbers\n", "\n", " \"\"\"\n", "\n", " predict = self._feedforward(X)\n", "\n", " if self.classification:\n", " return np.where(predict > threshold, 1, 0)\n", " else:\n", " return predict\n", "\n", " def reset_weights(self):\n", " \"\"\"\n", " Description:\n", " ------------\n", " Resets/Reinitializes the weights in order to train the network for a new problem.\n", "\n", " \"\"\"\n", " if self.seed is not None:\n", " np.random.seed(self.seed)\n", "\n", " self.weights = list()\n", " for i in range(len(self.dimensions) - 1):\n", " weight_array = np.random.randn(\n", " self.dimensions[i] + 1, self.dimensions[i + 1]\n", " )\n", " weight_array[0, :] = np.random.randn(self.dimensions[i + 1]) * 0.01\n", "\n", " self.weights.append(weight_array)\n", "\n", " def _feedforward(self, X: np.ndarray):\n", " \"\"\"\n", " Description:\n", " ------------\n", " Calculates the activation of each layer starting at the input and ending at the output.\n", " Each following activation is calculated from a weighted sum of each of the preceeding\n", " activations (except in the case of the input layer).\n", "\n", " Parameters:\n", " ------------\n", " I X (np.ndarray): The design matrix, with n rows of p features each\n", "\n", " Returns:\n", " ------------\n", " I z (np.ndarray): A prediction vector (row) for each row in our design matrix\n", " \"\"\"\n", "\n", " # reset matrices\n", " self.a_matrices = list()\n", " self.z_matrices = list()\n", "\n", " # if X is just a vector, make it into a matrix\n", " if len(X.shape) == 1:\n", " X = X.reshape((1, X.shape[0]))\n", "\n", " # Add a coloumn of zeros as the first coloumn of the design matrix, in order\n", " # to add bias to our data\n", " bias = np.ones((X.shape[0], 1)) * 0.01\n", " X = np.hstack([bias, X])\n", "\n", " # a^0, the nodes in the input layer (one a^0 for each row in X - where the\n", " # exponent indicates layer number).\n", " a = X\n", " self.a_matrices.append(a)\n", " self.z_matrices.append(a)\n", "\n", " # The feed forward algorithm\n", " for i in range(len(self.weights)):\n", " if i < len(self.weights) - 1:\n", " z = a @ self.weights[i]\n", " self.z_matrices.append(z)\n", " a = self.hidden_func(z)\n", " # bias column again added to the data here\n", " bias = np.ones((a.shape[0], 1)) * 0.01\n", " a = np.hstack([bias, a])\n", " self.a_matrices.append(a)\n", " else:\n", " try:\n", " # a^L, the nodes in our output layers\n", " z = a @ self.weights[i]\n", " a = self.output_func(z)\n", " self.a_matrices.append(a)\n", " self.z_matrices.append(z)\n", " except Exception as OverflowError:\n", " print(\n", " \"OverflowError in fit() in FFNN\\nHOW TO DEBUG ERROR: Consider lowering your learning rate or scheduler specific parameters such as momentum, or check if your input values need scaling\"\n", " )\n", "\n", " # this will be a^L\n", " return a\n", "\n", " def _backpropagate(self, X, t, lam):\n", " \"\"\"\n", " Description:\n", " ------------\n", " Performs the backpropagation algorithm. In other words, this method\n", " calculates the gradient of all the layers starting at the\n", " output layer, and moving from right to left accumulates the gradient until\n", " the input layer is reached. Each layers respective weights are updated while\n", " the algorithm propagates backwards from the output layer (auto-differentation in reverse mode).\n", "\n", " Parameters:\n", " ------------\n", " I X (np.ndarray): The design matrix, with n rows of p features each.\n", " II t (np.ndarray): The target vector, with n rows of p targets.\n", " III lam (float32): regularization parameter used to punish the weights in case of overfitting\n", "\n", " Returns:\n", " ------------\n", " No return value.\n", "\n", " \"\"\"\n", " out_derivative = derivate(self.output_func)\n", " hidden_derivative = derivate(self.hidden_func)\n", "\n", " for i in range(len(self.weights) - 1, -1, -1):\n", " # delta terms for output\n", " if i == len(self.weights) - 1:\n", " # for multi-class classification\n", " if (\n", " self.output_func.__name__ == \"softmax\"\n", " ):\n", " delta_matrix = self.a_matrices[i + 1] - t\n", " # for single class classification\n", " else:\n", " cost_func_derivative = grad(self.cost_func(t))\n", " delta_matrix = out_derivative(\n", " self.z_matrices[i + 1]\n", " ) * cost_func_derivative(self.a_matrices[i + 1])\n", "\n", " # delta terms for hidden layer\n", " else:\n", " delta_matrix = (\n", " self.weights[i + 1][1:, :] @ delta_matrix.T\n", " ).T * hidden_derivative(self.z_matrices[i + 1])\n", "\n", " # calculate gradient\n", " gradient_weights = self.a_matrices[i][:, 1:].T @ delta_matrix\n", " gradient_bias = np.sum(delta_matrix, axis=0).reshape(\n", " 1, delta_matrix.shape[1]\n", " )\n", "\n", " # regularization term\n", " gradient_weights += self.weights[i][1:, :] * lam\n", "\n", " # use scheduler\n", " update_matrix = np.vstack(\n", " [\n", " self.schedulers_bias[i].update_change(gradient_bias),\n", " self.schedulers_weight[i].update_change(gradient_weights),\n", " ]\n", " )\n", "\n", " # update weights and bias\n", " self.weights[i] -= update_matrix\n", "\n", " def _accuracy(self, prediction: np.ndarray, target: np.ndarray):\n", " \"\"\"\n", " Description:\n", " ------------\n", " Calculates accuracy of given prediction to target\n", "\n", " Parameters:\n", " ------------\n", " I prediction (np.ndarray): vector of predicitons output network\n", " (1s and 0s in case of classification, and real numbers in case of regression)\n", " II target (np.ndarray): vector of true values (What the network ideally should predict)\n", "\n", " Returns:\n", " ------------\n", " A floating point number representing the percentage of correctly classified instances.\n", " \"\"\"\n", " assert prediction.size == target.size\n", " return np.average((target == prediction))\n", " def _set_classification(self):\n", " \"\"\"\n", " Description:\n", " ------------\n", " Decides if FFNN acts as classifier (True) og regressor (False),\n", " sets self.classification during init()\n", " \"\"\"\n", " self.classification = False\n", " if (\n", " self.cost_func.__name__ == \"CostLogReg\"\n", " or self.cost_func.__name__ == \"CostCrossEntropy\"\n", " ):\n", " self.classification = True\n", "\n", " def _progress_bar(self, progression, **kwargs):\n", " \"\"\"\n", " Description:\n", " ------------\n", " Displays progress of training\n", " \"\"\"\n", " print_length = 40\n", " num_equals = int(progression * print_length)\n", " num_not = print_length - num_equals\n", " arrow = \">\" if num_equals > 0 else \"\"\n", " bar = \"[\" + \"=\" * (num_equals - 1) + arrow + \"-\" * num_not + \"]\"\n", " perc_print = self._format(progression * 100, decimals=5)\n", " line = f\" {bar} {perc_print}% \"\n", "\n", " for key in kwargs:\n", " if not np.isnan(kwargs[key]):\n", " value = self._format(kwargs[key], decimals=4)\n", " line += f\"| {key}: {value} \"\n", " sys.stdout.write(\"\\r\" + line)\n", " sys.stdout.flush()\n", " return len(line)\n", "\n", " def _format(self, value, decimals=4):\n", " \"\"\"\n", " Description:\n", " ------------\n", " Formats decimal numbers for progress bar\n", " \"\"\"\n", " if value > 0:\n", " v = value\n", " elif value < 0:\n", " v = -10 * value\n", " else:\n", " v = 1\n", " n = 1 + math.floor(math.log10(v))\n", " if n >= decimals - 1:\n", " return str(round(value))\n", " return f\"{value:.{decimals-n-1}f}\"" ] }, { "cell_type": "markdown", "id": "e4ba55d0", "metadata": {}, "source": [ "Before we make a model, we will quickly generate a dataset we can use\n", "for our linear regression problem as shown below" ] }, { "cell_type": "code", "execution_count": 11, "id": "c72a22c6", "metadata": {}, "outputs": [], "source": [ "import autograd.numpy as np\n", "from sklearn.model_selection import train_test_split\n", "\n", "def SkrankeFunction(x, y):\n", " return np.ravel(0 + 1*x + 2*y + 3*x**2 + 4*x*y + 5*y**2)\n", "\n", "def create_X(x, y, n):\n", " if len(x.shape) > 1:\n", " x = np.ravel(x)\n", " y = np.ravel(y)\n", "\n", " N = len(x)\n", " l = int((n + 1) * (n + 2) / 2) # Number of elements in beta\n", " X = np.ones((N, l))\n", "\n", " for i in range(1, n + 1):\n", " q = int((i) * (i + 1) / 2)\n", " for k in range(i + 1):\n", " X[:, q + k] = (x ** (i - k)) * (y**k)\n", "\n", " return X\n", "\n", "step=0.5\n", "x = np.arange(0, 1, step)\n", "y = np.arange(0, 1, step)\n", "x, y = np.meshgrid(x, y)\n", "target = SkrankeFunction(x, y)\n", "target = target.reshape(target.shape[0], 1)\n", "\n", "poly_degree=3\n", "X = create_X(x, y, poly_degree)\n", "\n", "X_train, X_test, t_train, t_test = train_test_split(X, target)" ] }, { "cell_type": "markdown", "id": "25b63b47", "metadata": {}, "source": [ "Now that we have our dataset ready for the regression, we can create\n", "our regressor. Note that with the seed parameter, we can make sure our\n", "results stay the same every time we run the neural network. For\n", "inititialization, we simply specify the dimensions (we wish the amount\n", "of input nodes to be equal to the datapoints, and the output to\n", "predict one value)." ] }, { "cell_type": "code", "execution_count": 12, "id": "b6b4e461", "metadata": {}, "outputs": [], "source": [ "input_nodes = X_train.shape[1]\n", "output_nodes = 1\n", "\n", "linear_regression = FFNN((input_nodes, output_nodes), output_func=identity, cost_func=CostOLS, seed=2023)" ] }, { "cell_type": "markdown", "id": "d7860b74", "metadata": {}, "source": [ "We then fit our model with our training data using the scheduler of our choice." ] }, { "cell_type": "code", "execution_count": 13, "id": "00522c73", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Constant: Eta=0.001, Lambda=0\n", "\r", " [----------------------------------------] 0.000% | train_error: 3.69 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.000% | train_error: 3.67 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.000% | train_error: 3.65 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.000% | train_error: 3.64 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.000% | train_error: 3.62 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.000% | train_error: 3.60 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.000% | train_error: 3.58 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.000% | train_error: 3.57 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.000% | train_error: 3.55 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.000% | train_error: 3.53 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.00% | train_error: 3.52 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.00% | train_error: 3.50 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.00% | train_error: 3.48 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.00% | train_error: 3.47 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.00% | train_error: 3.45 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.00% | train_error: 3.43 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.00% | train_error: 3.42 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.00% | train_error: 3.40 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.00% | train_error: 3.38 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.00% | train_error: 3.37 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.00% | train_error: 3.35 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.00% | train_error: 3.34 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.00% | train_error: 3.32 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.00% | train_error: 3.31 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.00% | train_error: 3.29 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.00% | train_error: 3.27 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.00% | train_error: 3.26 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.00% | train_error: 3.24 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.00% | train_error: 3.23 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.00% | train_error: 3.21 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.00% | train_error: 3.20 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.00% | train_error: 3.18 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.00% | train_error: 3.17 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.00% | train_error: 3.15 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.00% | train_error: 3.14 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.00% | train_error: 3.12 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.00% | train_error: 3.11 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.00% | train_error: 3.09 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.00% | train_error: 3.08 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.00% | train_error: 3.06 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.00% | train_error: 3.05 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.00% | train_error: 3.03 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.00% | train_error: 3.02 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.00% | train_error: 3.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.00% | train_error: 2.99 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.00% | train_error: 2.98 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.00% | train_error: 2.96 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.00% | train_error: 2.95 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.00% | train_error: 2.93 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.00% | train_error: 2.92 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.00% | train_error: 2.91 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.00% | train_error: 2.89 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.00% | train_error: 2.88 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.00% | train_error: 2.86 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.00% | train_error: 2.85 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.00% | train_error: 2.84 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.00% | train_error: 2.82 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.00% | train_error: 2.81 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.00% | train_error: 2.80 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.00% | train_error: 2.78 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.00% | train_error: 2.77 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.00% | train_error: 2.76 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.00% | train_error: 2.74 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.00% | train_error: 2.73 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.00% | train_error: 2.72 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.00% | train_error: 2.70 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.00% | train_error: 2.69 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.00% | train_error: 2.68 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.00% | train_error: 2.67 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.00% | train_error: 2.65 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.00% | train_error: 2.64 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.00% | train_error: 2.63 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.00% | train_error: 2.62 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.00% | train_error: 2.60 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.00% | train_error: 2.59 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.00% | train_error: 2.58 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.00% | train_error: 2.57 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.00% | train_error: 2.55 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.00% | train_error: 2.54 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.00% | train_error: 2.53 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.00% | train_error: 2.52 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.00% | train_error: 2.51 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.00% | train_error: 2.49 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.00% | train_error: 2.48 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.00% | train_error: 2.47 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.00% | train_error: 2.46 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.00% | train_error: 2.45 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.00% | train_error: 2.44 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.00% | train_error: 2.42 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.00% | train_error: 2.41 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.00% | train_error: 2.40 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.00% | train_error: 2.39 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.00% | train_error: 2.38 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.00% | train_error: 2.37 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.00% | train_error: 2.36 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.00% | train_error: 2.34 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.00% | train_error: 2.33 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.00% | train_error: 2.32 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.00% | train_error: 2.31 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.00% | train_error: 2.30 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================================>] 100.0% | train_error: 2.30 " ] } ], "source": [ "linear_regression.reset_weights() # reset weights such that previous runs or reruns don't affect the weights\n", "\n", "scheduler = Constant(eta=1e-3)\n", "scores = linear_regression.fit(X_train, t_train, scheduler)" ] }, { "cell_type": "markdown", "id": "a57bfb12", "metadata": {}, "source": [ "Due to the progress bar we can see the MSE (train_error) throughout\n", "the FFNN's training. Note that the fit() function has some optional\n", "parameters with defualt arguments. For example, the regularization\n", "hyperparameter can be left ignored if not needed, and equally the FFNN\n", "will by default run for 100 epochs. These can easily be changed, such\n", "as for example:" ] }, { "cell_type": "code", "execution_count": 14, "id": "35259e41", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Constant: Eta=0.001, Lambda=0.0001\n", "\r", " [----------------------------------------] 0.000% | train_error: 3.69 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.1000% | train_error: 3.67 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.2000% | train_error: 3.65 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.3000% | train_error: 3.64 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.4000% | train_error: 3.62 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.5000% | train_error: 3.60 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.6000% | train_error: 3.58 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.7000% | train_error: 3.57 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.8000% | train_error: 3.55 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.9000% | train_error: 3.53 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.000% | train_error: 3.52 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.100% | train_error: 3.50 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.200% | train_error: 3.48 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.300% | train_error: 3.47 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.400% | train_error: 3.45 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.500% | train_error: 3.43 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.600% | train_error: 3.42 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.700% | train_error: 3.40 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.800% | train_error: 3.38 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.900% | train_error: 3.37 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.000% | train_error: 3.35 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.100% | train_error: 3.34 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.200% | train_error: 3.32 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.300% | train_error: 3.31 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.400% | train_error: 3.29 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.500% | train_error: 3.27 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.600% | train_error: 3.26 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.700% | train_error: 3.24 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.800% | train_error: 3.23 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.900% | train_error: 3.21 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.000% | train_error: 3.20 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.100% | train_error: 3.18 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.200% | train_error: 3.17 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.300% | train_error: 3.15 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.400% | train_error: 3.14 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.500% | train_error: 3.12 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.600% | train_error: 3.11 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.700% | train_error: 3.09 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.800% | train_error: 3.08 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.900% | train_error: 3.06 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.000% | train_error: 3.05 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.100% | train_error: 3.03 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.200% | train_error: 3.02 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.300% | train_error: 3.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.400% | train_error: 2.99 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.500% | train_error: 2.98 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.600% | train_error: 2.96 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.700% | train_error: 2.95 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.800% | train_error: 2.93 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.900% | train_error: 2.92 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.000% | train_error: 2.91 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.100% | train_error: 2.89 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.200% | train_error: 2.88 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.300% | train_error: 2.86 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.400% | train_error: 2.85 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.500% | train_error: 2.84 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.600% | train_error: 2.82 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.700% | train_error: 2.81 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.800% | train_error: 2.80 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.900% | train_error: 2.78 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.000% | train_error: 2.77 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.100% | train_error: 2.76 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.200% | train_error: 2.74 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.300% | train_error: 2.73 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.400% | train_error: 2.72 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.500% | train_error: 2.70 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.600% | train_error: 2.69 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.700% | train_error: 2.68 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.800% | train_error: 2.67 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.900% | train_error: 2.65 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.000% | train_error: 2.64 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.100% | train_error: 2.63 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.200% | train_error: 2.62 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.300% | train_error: 2.60 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.400% | train_error: 2.59 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.500% | train_error: 2.58 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.600% | train_error: 2.57 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.700% | train_error: 2.55 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.800% | train_error: 2.54 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.900% | train_error: 2.53 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.000% | train_error: 2.52 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.100% | train_error: 2.51 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.200% | train_error: 2.49 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.300% | train_error: 2.48 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.400% | train_error: 2.47 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.500% | train_error: 2.46 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.600% | train_error: 2.45 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.700% | train_error: 2.44 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.800% | train_error: 2.42 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.900% | train_error: 2.41 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.000% | train_error: 2.40 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.100% | train_error: 2.39 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.200% | train_error: 2.38 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.300% | train_error: 2.37 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.400% | train_error: 2.36 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.500% | train_error: 2.34 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.600% | train_error: 2.33 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.700% | train_error: 2.32 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.800% | train_error: 2.31 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.900% | train_error: 2.30 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.00% | train_error: 2.29 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.10% | train_error: 2.28 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.20% | train_error: 2.27 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.30% | train_error: 2.26 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.40% | train_error: 2.25 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.50% | train_error: 2.23 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.60% | train_error: 2.22 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.70% | train_error: 2.21 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.80% | train_error: 2.20 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.90% | train_error: 2.19 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.00% | train_error: 2.18 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.10% | train_error: 2.17 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.20% | train_error: 2.16 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.30% | train_error: 2.15 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.40% | train_error: 2.14 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.50% | train_error: 2.13 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.60% | train_error: 2.12 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.70% | train_error: 2.11 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.80% | train_error: 2.10 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.90% | train_error: 2.09 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.00% | train_error: 2.08 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.10% | train_error: 2.07 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.20% | train_error: 2.06 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.30% | train_error: 2.05 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.40% | train_error: 2.04 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.50% | train_error: 2.03 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.60% | train_error: 2.02 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.70% | train_error: 2.01 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.80% | train_error: 2.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.90% | train_error: 1.99 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.00% | train_error: 1.98 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.10% | train_error: 1.97 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.20% | train_error: 1.96 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.30% | train_error: 1.96 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.40% | train_error: 1.95 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.50% | train_error: 1.94 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.60% | train_error: 1.93 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.70% | train_error: 1.92 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.80% | train_error: 1.91 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.90% | train_error: 1.90 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.00% | train_error: 1.89 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.10% | train_error: 1.88 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.20% | train_error: 1.87 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.30% | train_error: 1.86 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.40% | train_error: 1.86 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.50% | train_error: 1.85 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.60% | train_error: 1.84 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.70% | train_error: 1.83 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.80% | train_error: 1.82 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.90% | train_error: 1.81 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.00% | train_error: 1.80 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.10% | train_error: 1.79 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.20% | train_error: 1.79 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.30% | train_error: 1.78 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.40% | train_error: 1.77 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.50% | train_error: 1.76 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.60% | train_error: 1.75 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.70% | train_error: 1.74 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.80% | train_error: 1.74 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.90% | train_error: 1.73 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.00% | train_error: 1.72 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.10% | train_error: 1.71 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.20% | train_error: 1.70 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.30% | train_error: 1.69 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.40% | train_error: 1.69 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.50% | train_error: 1.68 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.60% | train_error: 1.67 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.70% | train_error: 1.66 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.80% | train_error: 1.65 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.90% | train_error: 1.65 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.00% | train_error: 1.64 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.10% | train_error: 1.63 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.20% | train_error: 1.62 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.30% | train_error: 1.62 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.40% | train_error: 1.61 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.50% | train_error: 1.60 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.60% | train_error: 1.59 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.70% | train_error: 1.59 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.80% | train_error: 1.58 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.90% | train_error: 1.57 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.00% | train_error: 1.56 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.10% | train_error: 1.56 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.20% | train_error: 1.55 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.30% | train_error: 1.54 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.40% | train_error: 1.53 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.50% | train_error: 1.53 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.60% | train_error: 1.52 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.70% | train_error: 1.51 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.80% | train_error: 1.50 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.90% | train_error: 1.50 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.00% | train_error: 1.49 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.10% | train_error: 1.48 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.20% | train_error: 1.48 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.30% | train_error: 1.47 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.40% | train_error: 1.46 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.50% | train_error: 1.46 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.60% | train_error: 1.45 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.70% | train_error: 1.44 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.80% | train_error: 1.43 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.90% | train_error: 1.43 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.00% | train_error: 1.42 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.10% | train_error: 1.41 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.20% | train_error: 1.41 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.30% | train_error: 1.40 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.40% | train_error: 1.39 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.50% | train_error: 1.39 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.60% | train_error: 1.38 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.70% | train_error: 1.37 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.80% | train_error: 1.37 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.90% | train_error: 1.36 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.00% | train_error: 1.35 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.10% | train_error: 1.35 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.20% | train_error: 1.34 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.30% | train_error: 1.34 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.40% | train_error: 1.33 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.50% | train_error: 1.32 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.60% | train_error: 1.32 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.70% | train_error: 1.31 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.80% | train_error: 1.30 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.90% | train_error: 1.30 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.00% | train_error: 1.29 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.10% | train_error: 1.29 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.20% | train_error: 1.28 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.30% | train_error: 1.27 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.40% | train_error: 1.27 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.50% | train_error: 1.26 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.60% | train_error: 1.26 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.70% | train_error: 1.25 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.80% | train_error: 1.24 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.90% | train_error: 1.24 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.00% | train_error: 1.23 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.10% | train_error: 1.23 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.20% | train_error: 1.22 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.30% | train_error: 1.21 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.40% | train_error: 1.21 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.50% | train_error: 1.20 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.60% | train_error: 1.20 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.70% | train_error: 1.19 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.80% | train_error: 1.19 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.90% | train_error: 1.18 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.00% | train_error: 1.17 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.10% | train_error: 1.17 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.20% | train_error: 1.16 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.30% | train_error: 1.16 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.40% | train_error: 1.15 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.50% | train_error: 1.15 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.60% | train_error: 1.14 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.70% | train_error: 1.14 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.80% | train_error: 1.13 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.90% | train_error: 1.13 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.00% | train_error: 1.12 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.10% | train_error: 1.11 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.20% | train_error: 1.11 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.30% | train_error: 1.10 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.40% | train_error: 1.10 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.50% | train_error: 1.09 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.60% | train_error: 1.09 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.70% | train_error: 1.08 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.80% | train_error: 1.08 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.90% | train_error: 1.07 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.00% | train_error: 1.07 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.10% | train_error: 1.06 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.20% | train_error: 1.06 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.30% | train_error: 1.05 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.40% | train_error: 1.05 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.50% | train_error: 1.04 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.60% | train_error: 1.04 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.70% | train_error: 1.03 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.80% | train_error: 1.03 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.90% | train_error: 1.02 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.00% | train_error: 1.02 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.10% | train_error: 1.01 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.20% | train_error: 1.01 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.30% | train_error: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.40% | train_error: 0.999 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.50% | train_error: 0.994 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.60% | train_error: 0.990 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.70% | train_error: 0.985 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.80% | train_error: 0.980 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.90% | train_error: 0.976 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.00% | train_error: 0.971 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.10% | train_error: 0.966 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.20% | train_error: 0.962 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.30% | train_error: 0.957 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.40% | train_error: 0.953 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.50% | train_error: 0.948 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.60% | train_error: 0.944 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.70% | train_error: 0.939 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.80% | train_error: 0.935 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.90% | train_error: 0.930 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.00% | train_error: 0.926 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.10% | train_error: 0.922 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.20% | train_error: 0.917 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.30% | train_error: 0.913 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.40% | train_error: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.50% | train_error: 0.904 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.60% | train_error: 0.900 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.70% | train_error: 0.896 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.80% | train_error: 0.891 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.90% | train_error: 0.887 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.00% | train_error: 0.883 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.10% | train_error: 0.879 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.20% | train_error: 0.875 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.30% | train_error: 0.870 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.40% | train_error: 0.866 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.50% | train_error: 0.862 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.60% | train_error: 0.858 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.70% | train_error: 0.854 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.80% | train_error: 0.850 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.90% | train_error: 0.846 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.00% | train_error: 0.842 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.10% | train_error: 0.838 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.20% | train_error: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.30% | train_error: 0.830 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.40% | train_error: 0.826 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.50% | train_error: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.60% | train_error: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.70% | train_error: 0.814 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.80% | train_error: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.90% | train_error: 0.807 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.00% | train_error: 0.803 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.10% | train_error: 0.799 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.20% | train_error: 0.795 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.30% | train_error: 0.792 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.40% | train_error: 0.788 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.50% | train_error: 0.784 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.60% | train_error: 0.780 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.70% | train_error: 0.777 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.80% | train_error: 0.773 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.90% | train_error: 0.769 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.00% | train_error: 0.766 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.10% | train_error: 0.762 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.20% | train_error: 0.759 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.30% | train_error: 0.755 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.40% | train_error: 0.751 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.50% | train_error: 0.748 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.60% | train_error: 0.744 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.70% | train_error: 0.741 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.80% | train_error: 0.737 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.90% | train_error: 0.734 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.00% | train_error: 0.730 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.10% | train_error: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.20% | train_error: 0.723 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.30% | train_error: 0.720 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.40% | train_error: 0.717 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.50% | train_error: 0.713 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.60% | train_error: 0.710 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.70% | train_error: 0.706 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.80% | train_error: 0.703 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.90% | train_error: 0.700 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.00% | train_error: 0.696 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.10% | train_error: 0.693 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.20% | train_error: 0.690 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.30% | train_error: 0.687 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.40% | train_error: 0.683 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.50% | train_error: 0.680 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.60% | train_error: 0.677 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.70% | train_error: 0.674 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.80% | train_error: 0.670 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.90% | train_error: 0.667 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.00% | train_error: 0.664 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.10% | train_error: 0.661 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.20% | train_error: 0.658 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.30% | train_error: 0.655 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.40% | train_error: 0.652 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.50% | train_error: 0.649 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.60% | train_error: 0.646 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.70% | train_error: 0.642 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.80% | train_error: 0.639 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.90% | train_error: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.00% | train_error: 0.633 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.10% | train_error: 0.630 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.20% | train_error: 0.627 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.30% | train_error: 0.624 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.40% | train_error: 0.622 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.50% | train_error: 0.619 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.60% | train_error: 0.616 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.70% | train_error: 0.613 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.80% | train_error: 0.610 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.90% | train_error: 0.607 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.00% | train_error: 0.604 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.10% | train_error: 0.601 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.20% | train_error: 0.598 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.30% | train_error: 0.596 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.40% | train_error: 0.593 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.50% | train_error: 0.590 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.60% | train_error: 0.587 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.70% | train_error: 0.584 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.80% | train_error: 0.582 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.90% | train_error: 0.579 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.00% | train_error: 0.576 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.10% | train_error: 0.573 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.20% | train_error: 0.571 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.30% | train_error: 0.568 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.40% | train_error: 0.565 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.50% | train_error: 0.563 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.60% | train_error: 0.560 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.70% | train_error: 0.557 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.80% | train_error: 0.555 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.90% | train_error: 0.552 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.00% | train_error: 0.549 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.10% | train_error: 0.547 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.20% | train_error: 0.544 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.30% | train_error: 0.542 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.40% | train_error: 0.539 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.50% | train_error: 0.537 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.60% | train_error: 0.534 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.70% | train_error: 0.532 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.80% | train_error: 0.529 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.90% | train_error: 0.527 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.00% | train_error: 0.524 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.10% | train_error: 0.522 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.20% | train_error: 0.519 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.30% | train_error: 0.517 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.40% | train_error: 0.514 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.50% | train_error: 0.512 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.60% | train_error: 0.509 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.70% | train_error: 0.507 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.80% | train_error: 0.505 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.90% | train_error: 0.502 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.00% | train_error: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.10% | train_error: 0.498 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.20% | train_error: 0.495 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.30% | train_error: 0.493 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.40% | train_error: 0.491 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.50% | train_error: 0.488 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.60% | train_error: 0.486 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.70% | train_error: 0.484 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.80% | train_error: 0.481 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.90% | train_error: 0.479 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.00% | train_error: 0.477 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.10% | train_error: 0.475 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.20% | train_error: 0.472 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.30% | train_error: 0.470 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.40% | train_error: 0.468 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.50% | train_error: 0.466 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.60% | train_error: 0.463 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.70% | train_error: 0.461 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.80% | train_error: 0.459 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.90% | train_error: 0.457 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.00% | train_error: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.10% | train_error: 0.453 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.20% | train_error: 0.451 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.30% | train_error: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.40% | train_error: 0.446 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.50% | train_error: 0.444 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.60% | train_error: 0.442 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.70% | train_error: 0.440 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.80% | train_error: 0.438 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.90% | train_error: 0.436 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.00% | train_error: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.10% | train_error: 0.432 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.20% | train_error: 0.430 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.30% | train_error: 0.428 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.40% | train_error: 0.426 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.50% | train_error: 0.424 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.60% | train_error: 0.422 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.70% | train_error: 0.420 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.80% | train_error: 0.418 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.90% | train_error: 0.416 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.00% | train_error: 0.414 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.10% | train_error: 0.412 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.20% | train_error: 0.410 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.30% | train_error: 0.408 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.40% | train_error: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.50% | train_error: 0.404 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.60% | train_error: 0.402 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.70% | train_error: 0.400 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.80% | train_error: 0.398 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.90% | train_error: 0.397 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.00% | train_error: 0.395 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.10% | train_error: 0.393 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.20% | train_error: 0.391 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.30% | train_error: 0.389 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.40% | train_error: 0.387 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.50% | train_error: 0.386 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.60% | train_error: 0.384 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.70% | train_error: 0.382 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.80% | train_error: 0.380 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.90% | train_error: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.00% | train_error: 0.377 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.10% | train_error: 0.375 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.20% | train_error: 0.373 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.30% | train_error: 0.371 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.40% | train_error: 0.370 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.50% | train_error: 0.368 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.60% | train_error: 0.366 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.70% | train_error: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.80% | train_error: 0.363 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.90% | train_error: 0.361 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.00% | train_error: 0.359 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.10% | train_error: 0.358 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.20% | train_error: 0.356 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.30% | train_error: 0.354 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.40% | train_error: 0.353 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.50% | train_error: 0.351 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.60% | train_error: 0.349 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.70% | train_error: 0.348 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.80% | train_error: 0.346 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.90% | train_error: 0.344 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.00% | train_error: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.10% | train_error: 0.341 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.20% | train_error: 0.339 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.30% | train_error: 0.338 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.40% | train_error: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.50% | train_error: 0.335 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.60% | train_error: 0.333 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.70% | train_error: 0.332 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.80% | train_error: 0.330 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.90% | train_error: 0.328 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.00% | train_error: 0.327 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.10% | train_error: 0.325 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.20% | train_error: 0.324 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.30% | train_error: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.40% | train_error: 0.321 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.50% | train_error: 0.319 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.60% | train_error: 0.318 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.70% | train_error: 0.316 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.80% | train_error: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.90% | train_error: 0.313 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.00% | train_error: 0.312 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.10% | train_error: 0.310 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.20% | train_error: 0.309 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.30% | train_error: 0.308 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.40% | train_error: 0.306 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.50% | train_error: 0.305 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.60% | train_error: 0.303 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.70% | train_error: 0.302 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.80% | train_error: 0.300 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.90% | train_error: 0.299 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.00% | train_error: 0.298 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.10% | train_error: 0.296 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.20% | train_error: 0.295 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.30% | train_error: 0.293 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.40% | train_error: 0.292 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.50% | train_error: 0.291 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.60% | train_error: 0.289 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.70% | train_error: 0.288 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.80% | train_error: 0.287 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.90% | train_error: 0.285 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.00% | train_error: 0.284 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.10% | train_error: 0.283 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.20% | train_error: 0.281 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.30% | train_error: 0.280 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.40% | train_error: 0.279 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.50% | train_error: 0.277 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.60% | train_error: 0.276 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.70% | train_error: 0.275 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.80% | train_error: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.90% | train_error: 0.272 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.00% | train_error: 0.271 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.10% | train_error: 0.270 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.20% | train_error: 0.268 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.30% | train_error: 0.267 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.40% | train_error: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.50% | train_error: 0.265 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.60% | train_error: 0.263 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.70% | train_error: 0.262 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.80% | train_error: 0.261 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.90% | train_error: 0.260 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.00% | train_error: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.10% | train_error: 0.257 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.20% | train_error: 0.256 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.30% | train_error: 0.255 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.40% | train_error: 0.254 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.50% | train_error: 0.253 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.60% | train_error: 0.251 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.70% | train_error: 0.250 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.80% | train_error: 0.249 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.90% | train_error: 0.248 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.00% | train_error: 0.247 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.10% | train_error: 0.246 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.20% | train_error: 0.244 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.30% | train_error: 0.243 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.40% | train_error: 0.242 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.50% | train_error: 0.241 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.60% | train_error: 0.240 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.70% | train_error: 0.239 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.80% | train_error: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.90% | train_error: 0.237 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.00% | train_error: 0.235 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.10% | train_error: 0.234 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.20% | train_error: 0.233 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.30% | train_error: 0.232 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.40% | train_error: 0.231 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.50% | train_error: 0.230 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.60% | train_error: 0.229 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.70% | train_error: 0.228 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.80% | train_error: 0.227 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.90% | train_error: 0.226 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.00% | train_error: 0.225 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.10% | train_error: 0.224 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.20% | train_error: 0.223 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.30% | train_error: 0.222 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.40% | train_error: 0.221 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.50% | train_error: 0.219 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.60% | train_error: 0.218 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.70% | train_error: 0.217 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.80% | train_error: 0.216 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.90% | train_error: 0.215 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.00% | train_error: 0.214 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.10% | train_error: 0.213 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.20% | train_error: 0.212 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.30% | train_error: 0.211 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.40% | train_error: 0.210 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.50% | train_error: 0.209 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.60% | train_error: 0.209 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.70% | train_error: 0.208 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.80% | train_error: 0.207 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.90% | train_error: 0.206 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.00% | train_error: 0.205 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.10% | train_error: 0.204 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.20% | train_error: 0.203 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.30% | train_error: 0.202 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.40% | train_error: 0.201 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.50% | train_error: 0.200 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.60% | train_error: 0.199 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.70% | train_error: 0.198 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.80% | train_error: 0.197 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.90% | train_error: 0.196 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.00% | train_error: 0.195 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.10% | train_error: 0.194 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.20% | train_error: 0.194 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.30% | train_error: 0.193 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.40% | train_error: 0.192 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.50% | train_error: 0.191 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.60% | train_error: 0.190 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.70% | train_error: 0.189 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.80% | train_error: 0.188 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.90% | train_error: 0.187 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.00% | train_error: 0.186 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.10% | train_error: 0.186 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.20% | train_error: 0.185 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.30% | train_error: 0.184 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.40% | train_error: 0.183 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.50% | train_error: 0.182 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.60% | train_error: 0.181 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.70% | train_error: 0.180 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.80% | train_error: 0.180 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.90% | train_error: 0.179 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.00% | train_error: 0.178 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.10% | train_error: 0.177 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.20% | train_error: 0.176 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.30% | train_error: 0.176 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.40% | train_error: 0.175 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.50% | train_error: 0.174 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.60% | train_error: 0.173 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.70% | train_error: 0.172 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.80% | train_error: 0.171 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.90% | train_error: 0.171 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.00% | train_error: 0.170 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.10% | train_error: 0.169 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.20% | train_error: 0.168 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.30% | train_error: 0.168 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.40% | train_error: 0.167 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.50% | train_error: 0.166 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.60% | train_error: 0.165 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.70% | train_error: 0.164 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.80% | train_error: 0.164 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.90% | train_error: 0.163 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.00% | train_error: 0.162 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.10% | train_error: 0.161 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.20% | train_error: 0.161 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.30% | train_error: 0.160 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.40% | train_error: 0.159 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.50% | train_error: 0.158 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.60% | train_error: 0.158 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.70% | train_error: 0.157 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.80% | train_error: 0.156 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.90% | train_error: 0.156 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.00% | train_error: 0.155 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.10% | train_error: 0.154 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.20% | train_error: 0.153 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.30% | train_error: 0.153 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.40% | train_error: 0.152 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.50% | train_error: 0.151 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.60% | train_error: 0.151 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.70% | train_error: 0.150 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.80% | train_error: 0.149 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.90% | train_error: 0.149 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.00% | train_error: 0.148 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.10% | train_error: 0.147 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.20% | train_error: 0.146 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.30% | train_error: 0.146 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.40% | train_error: 0.145 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.50% | train_error: 0.144 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.60% | train_error: 0.144 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.70% | train_error: 0.143 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.80% | train_error: 0.142 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.90% | train_error: 0.142 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.00% | train_error: 0.141 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.10% | train_error: 0.141 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.20% | train_error: 0.140 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.30% | train_error: 0.139 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.40% | train_error: 0.139 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.50% | train_error: 0.138 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.60% | train_error: 0.137 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.70% | train_error: 0.137 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.80% | train_error: 0.136 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.90% | train_error: 0.135 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.00% | train_error: 0.135 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.10% | train_error: 0.134 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.20% | train_error: 0.134 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.30% | train_error: 0.133 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.40% | train_error: 0.132 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.50% | train_error: 0.132 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.60% | train_error: 0.131 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.70% | train_error: 0.131 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.80% | train_error: 0.130 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.90% | train_error: 0.129 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.00% | train_error: 0.129 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.10% | train_error: 0.128 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.20% | train_error: 0.128 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.30% | train_error: 0.127 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.40% | train_error: 0.126 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.50% | train_error: 0.126 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.60% | train_error: 0.125 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.70% | train_error: 0.125 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.80% | train_error: 0.124 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.90% | train_error: 0.124 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.00% | train_error: 0.123 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.10% | train_error: 0.122 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.20% | train_error: 0.122 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.30% | train_error: 0.121 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.40% | train_error: 0.121 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.50% | train_error: 0.120 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.60% | train_error: 0.120 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.70% | train_error: 0.119 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.80% | train_error: 0.119 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.90% | train_error: 0.118 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.00% | train_error: 0.117 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.10% | train_error: 0.117 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.20% | train_error: 0.116 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.30% | train_error: 0.116 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.40% | train_error: 0.115 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.50% | train_error: 0.115 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.60% | train_error: 0.114 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.70% | train_error: 0.114 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.80% | train_error: 0.113 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.90% | train_error: 0.113 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.00% | train_error: 0.112 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.10% | train_error: 0.112 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.20% | train_error: 0.111 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.30% | train_error: 0.111 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.40% | train_error: 0.110 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.50% | train_error: 0.110 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.60% | train_error: 0.109 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.70% | train_error: 0.109 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.80% | train_error: 0.108 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.90% | train_error: 0.108 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.00% | train_error: 0.107 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.10% | train_error: 0.107 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.20% | train_error: 0.106 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.30% | train_error: 0.106 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.40% | train_error: 0.105 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.50% | train_error: 0.105 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.60% | train_error: 0.104 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.70% | train_error: 0.104 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.80% | train_error: 0.103 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.90% | train_error: 0.103 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.00% | train_error: 0.102 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.10% | train_error: 0.102 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.20% | train_error: 0.101 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.30% | train_error: 0.101 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.40% | train_error: 0.101 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.50% | train_error: 0.100 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.60% | train_error: 0.0996 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.70% | train_error: 0.0992 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.80% | train_error: 0.0987 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.90% | train_error: 0.0983 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.00% | train_error: 0.0978 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.10% | train_error: 0.0974 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.20% | train_error: 0.0969 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.30% | train_error: 0.0965 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.40% | train_error: 0.0961 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.50% | train_error: 0.0956 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.60% | train_error: 0.0952 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.70% | train_error: 0.0948 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.80% | train_error: 0.0943 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.90% | train_error: 0.0939 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.00% | train_error: 0.0935 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.10% | train_error: 0.0930 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.20% | train_error: 0.0926 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.30% | train_error: 0.0922 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.40% | train_error: 0.0918 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.50% | train_error: 0.0914 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.60% | train_error: 0.0910 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.70% | train_error: 0.0905 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.80% | train_error: 0.0901 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.90% | train_error: 0.0897 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.00% | train_error: 0.0893 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.10% | train_error: 0.0889 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.20% | train_error: 0.0885 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.30% | train_error: 0.0881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.40% | train_error: 0.0877 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.50% | train_error: 0.0873 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.60% | train_error: 0.0869 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.70% | train_error: 0.0865 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.80% | train_error: 0.0861 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.90% | train_error: 0.0858 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.00% | train_error: 0.0854 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.10% | train_error: 0.0850 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.20% | train_error: 0.0846 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.30% | train_error: 0.0842 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.40% | train_error: 0.0838 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.50% | train_error: 0.0835 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.60% | train_error: 0.0831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.70% | train_error: 0.0827 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.80% | train_error: 0.0823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.90% | train_error: 0.0820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.00% | train_error: 0.0816 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.10% | train_error: 0.0812 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.20% | train_error: 0.0809 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.30% | train_error: 0.0805 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.40% | train_error: 0.0801 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.50% | train_error: 0.0798 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.60% | train_error: 0.0794 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.70% | train_error: 0.0791 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.80% | train_error: 0.0787 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.90% | train_error: 0.0784 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.00% | train_error: 0.0780 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.10% | train_error: 0.0776 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.20% | train_error: 0.0773 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.30% | train_error: 0.0770 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.40% | train_error: 0.0766 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.50% | train_error: 0.0763 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.60% | train_error: 0.0759 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.70% | train_error: 0.0756 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.80% | train_error: 0.0752 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.90% | train_error: 0.0749 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.00% | train_error: 0.0746 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.10% | train_error: 0.0742 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.20% | train_error: 0.0739 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.30% | train_error: 0.0736 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.40% | train_error: 0.0732 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.50% | train_error: 0.0729 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.60% | train_error: 0.0726 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.70% | train_error: 0.0723 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.80% | train_error: 0.0719 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.90% | train_error: 0.0716 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.00% | train_error: 0.0713 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.10% | train_error: 0.0710 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.20% | train_error: 0.0707 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.30% | train_error: 0.0703 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.40% | train_error: 0.0700 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.50% | train_error: 0.0697 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.60% | train_error: 0.0694 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.70% | train_error: 0.0691 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.80% | train_error: 0.0688 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.90% | train_error: 0.0685 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.00% | train_error: 0.0682 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.10% | train_error: 0.0679 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.20% | train_error: 0.0676 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.30% | train_error: 0.0673 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.40% | train_error: 0.0670 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.50% | train_error: 0.0667 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.60% | train_error: 0.0664 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.70% | train_error: 0.0661 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.80% | train_error: 0.0658 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.90% | train_error: 0.0655 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.00% | train_error: 0.0652 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.10% | train_error: 0.0649 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.20% | train_error: 0.0646 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.30% | train_error: 0.0643 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.40% | train_error: 0.0641 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.50% | train_error: 0.0638 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.60% | train_error: 0.0635 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.70% | train_error: 0.0632 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.80% | train_error: 0.0629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.90% | train_error: 0.0626 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.00% | train_error: 0.0624 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.10% | train_error: 0.0621 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.20% | train_error: 0.0618 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.30% | train_error: 0.0615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.40% | train_error: 0.0613 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.50% | train_error: 0.0610 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.60% | train_error: 0.0607 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.70% | train_error: 0.0605 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.80% | train_error: 0.0602 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.90% | train_error: 0.0599 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.00% | train_error: 0.0597 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.10% | train_error: 0.0594 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.20% | train_error: 0.0591 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.30% | train_error: 0.0589 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.40% | train_error: 0.0586 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.50% | train_error: 0.0584 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.60% | train_error: 0.0581 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.70% | train_error: 0.0578 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.80% | train_error: 0.0576 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.90% | train_error: 0.0573 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.00% | train_error: 0.0571 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.10% | train_error: 0.0568 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.20% | train_error: 0.0566 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.30% | train_error: 0.0563 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.40% | train_error: 0.0561 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.50% | train_error: 0.0558 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.60% | train_error: 0.0556 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.70% | train_error: 0.0553 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.80% | train_error: 0.0551 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.90% | train_error: 0.0549 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.00% | train_error: 0.0546 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.10% | train_error: 0.0544 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.20% | train_error: 0.0541 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.30% | train_error: 0.0539 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.40% | train_error: 0.0537 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.50% | train_error: 0.0534 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.60% | train_error: 0.0532 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.70% | train_error: 0.0530 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.80% | train_error: 0.0527 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.90% | train_error: 0.0525 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.00% | train_error: 0.0523 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.10% | train_error: 0.0520 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.20% | train_error: 0.0518 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.30% | train_error: 0.0516 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.40% | train_error: 0.0514 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.50% | train_error: 0.0511 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.60% | train_error: 0.0509 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.70% | train_error: 0.0507 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.80% | train_error: 0.0505 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.90% | train_error: 0.0503 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.00% | train_error: 0.0500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.10% | train_error: 0.0498 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.20% | train_error: 0.0496 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.30% | train_error: 0.0494 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.40% | train_error: 0.0492 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.50% | train_error: 0.0490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.60% | train_error: 0.0487 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.70% | train_error: 0.0485 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.80% | train_error: 0.0483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.90% | train_error: 0.0481 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.00% | train_error: 0.0479 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.10% | train_error: 0.0477 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.20% | train_error: 0.0475 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.30% | train_error: 0.0473 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.40% | train_error: 0.0471 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.50% | train_error: 0.0469 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.60% | train_error: 0.0467 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.70% | train_error: 0.0465 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.80% | train_error: 0.0463 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.90% | train_error: 0.0461 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.00% | train_error: 0.0459 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.10% | train_error: 0.0457 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.20% | train_error: 0.0455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.30% | train_error: 0.0453 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.40% | train_error: 0.0451 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.50% | train_error: 0.0449 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.60% | train_error: 0.0447 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.70% | train_error: 0.0445 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.80% | train_error: 0.0443 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.90% | train_error: 0.0441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.00% | train_error: 0.0439 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.10% | train_error: 0.0437 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.20% | train_error: 0.0435 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.30% | train_error: 0.0434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.40% | train_error: 0.0432 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.50% | train_error: 0.0430 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.60% | train_error: 0.0428 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.70% | train_error: 0.0426 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.80% | train_error: 0.0424 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.90% | train_error: 0.0423 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.00% | train_error: 0.0421 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.10% | train_error: 0.0419 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.20% | train_error: 0.0417 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.30% | train_error: 0.0415 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.40% | train_error: 0.0414 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.50% | train_error: 0.0412 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.60% | train_error: 0.0410 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.70% | train_error: 0.0408 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.80% | train_error: 0.0407 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.90% | train_error: 0.0405 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.00% | train_error: 0.0403 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.10% | train_error: 0.0401 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.20% | train_error: 0.0400 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.30% | train_error: 0.0398 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.40% | train_error: 0.0396 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.50% | train_error: 0.0395 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.60% | train_error: 0.0393 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.70% | train_error: 0.0391 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.80% | train_error: 0.0389 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.90% | train_error: 0.0388 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.00% | train_error: 0.0386 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.10% | train_error: 0.0385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.20% | train_error: 0.0383 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.30% | train_error: 0.0381 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.40% | train_error: 0.0380 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.50% | train_error: 0.0378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.60% | train_error: 0.0376 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.70% | train_error: 0.0375 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.80% | train_error: 0.0373 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.90% | train_error: 0.0372 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.00% | train_error: 0.0370 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.10% | train_error: 0.0369 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.20% | train_error: 0.0367 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.30% | train_error: 0.0365 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.40% | train_error: 0.0364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.50% | train_error: 0.0362 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.60% | train_error: 0.0361 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.70% | train_error: 0.0359 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.80% | train_error: 0.0358 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.90% | train_error: 0.0356 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================================>] 100.0% | train_error: 0.0356 " ] } ], "source": [ "linear_regression.reset_weights() # reset weights such that previous runs or reruns don't affect the weights\n", "\n", "scores = linear_regression.fit(X_train, t_train, scheduler, lam=1e-4, epochs=1000)" ] }, { "cell_type": "markdown", "id": "4a403370", "metadata": {}, "source": [ "We see that given more epochs to train on, the regressor reaches a lower MSE.\n", "\n", "Let us then switch to a binary classification. We use a binary\n", "classification dataset, and follow a similar setup to the regression\n", "case." ] }, { "cell_type": "code", "execution_count": 15, "id": "6c791130", "metadata": {}, "outputs": [], "source": [ "from sklearn.datasets import load_breast_cancer\n", "from sklearn.preprocessing import MinMaxScaler\n", "\n", "wisconsin = load_breast_cancer()\n", "X = wisconsin.data\n", "target = wisconsin.target\n", "target = target.reshape(target.shape[0], 1)\n", "\n", "X_train, X_val, t_train, t_val = train_test_split(X, target)\n", "\n", "scaler = MinMaxScaler()\n", "scaler.fit(X_train)\n", "X_train = scaler.transform(X_train)\n", "X_val = scaler.transform(X_val)" ] }, { "cell_type": "code", "execution_count": 16, "id": "0ac0258d", "metadata": {}, "outputs": [], "source": [ "input_nodes = X_train.shape[1]\n", "output_nodes = 1\n", "\n", "logistic_regression = FFNN((input_nodes, output_nodes), output_func=sigmoid, cost_func=CostLogReg, seed=2023)" ] }, { "cell_type": "markdown", "id": "a9c74baa", "metadata": {}, "source": [ "We will now make use of our validation data by passing it into our fit function as a keyword argument" ] }, { "cell_type": "code", "execution_count": 17, "id": "e5021bbf", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Adam: Eta=0.001, Lambda=0" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "\r", " [----------------------------------------] 0.000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.1000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.2000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.3000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.4000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.5000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.6000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.7000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.8000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.9000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.100% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.200% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.300% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.400% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.500% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.600% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.700% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.800% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.900% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.100% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.200% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.300% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.400% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.500% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.600% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.700% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.800% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.900% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.100% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.200% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.300% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.400% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.500% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.600% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.700% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.800% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.900% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.100% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.200% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.300% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.400% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.500% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.600% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.700% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.800% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.900% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.100% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.200% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.300% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.400% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.500% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.600% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.700% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.800% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.900% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.100% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.200% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.300% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.400% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.500% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.600% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.700% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.800% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.900% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.100% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.200% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.300% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.400% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.500% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.600% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.700% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.800% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.900% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.100% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.200% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.300% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.400% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.500% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.600% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.700% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.800% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.900% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.000% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.100% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.200% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.300% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.400% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.500% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.600% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.700% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.800% | train_error: 12.9 | train_acc: 0.376 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.900% | train_error: 13.0 | train_acc: 0.373 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.00% | train_error: 13.0 | train_acc: 0.373 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.10% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.20% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.30% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.40% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.50% | train_error: 13.0 | train_acc: 0.371 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.60% | train_error: 13.0 | train_acc: 0.371 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.70% | train_error: 13.0 | train_acc: 0.371 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.80% | train_error: 13.1 | train_acc: 0.369 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.90% | train_error: 13.1 | train_acc: 0.369 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.00% | train_error: 13.1 | train_acc: 0.369 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.10% | train_error: 13.1 | train_acc: 0.369 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.20% | train_error: 13.1 | train_acc: 0.369 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.30% | train_error: 13.1 | train_acc: 0.369 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.40% | train_error: 13.1 | train_acc: 0.369 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.50% | train_error: 13.1 | train_acc: 0.369 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.60% | train_error: 13.1 | train_acc: 0.369 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.70% | train_error: 13.1 | train_acc: 0.369 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.80% | train_error: 13.1 | train_acc: 0.369 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.90% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.00% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.10% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.20% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.30% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.40% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.50% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.60% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.70% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.80% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.90% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.00% | train_error: 13.1 | train_acc: 0.366 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.10% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.20% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.30% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.40% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.50% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.60% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.70% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.8 | val_acc: 0.385 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.80% | train_error: 13.3 | train_acc: 0.359 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.90% | train_error: 13.4 | train_acc: 0.354 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.00% | train_error: 13.4 | train_acc: 0.354 | val_error: 13.0 | val_acc: 0.371 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.10% | train_error: 13.4 | train_acc: 0.354 | val_error: 13.0 | val_acc: 0.371 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.20% | train_error: 13.4 | train_acc: 0.354 | val_error: 13.0 | val_acc: 0.371 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.30% | train_error: 13.4 | train_acc: 0.354 | val_error: 13.0 | val_acc: 0.371 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.40% | train_error: 13.4 | train_acc: 0.354 | val_error: 13.0 | val_acc: 0.371 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.50% | train_error: 13.4 | train_acc: 0.354 | val_error: 13.0 | val_acc: 0.371 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.60% | train_error: 13.4 | train_acc: 0.354 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.70% | train_error: 13.4 | train_acc: 0.354 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.80% | train_error: 13.4 | train_acc: 0.352 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.90% | train_error: 13.4 | train_acc: 0.352 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.00% | train_error: 13.5 | train_acc: 0.347 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.10% | train_error: 13.6 | train_acc: 0.345 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.20% | train_error: 13.6 | train_acc: 0.345 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.30% | train_error: 13.8 | train_acc: 0.336 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.40% | train_error: 13.8 | train_acc: 0.336 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.50% | train_error: 13.8 | train_acc: 0.336 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.60% | train_error: 13.8 | train_acc: 0.333 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.70% | train_error: 13.8 | train_acc: 0.333 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.80% | train_error: 13.8 | train_acc: 0.333 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.90% | train_error: 13.8 | train_acc: 0.333 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.00% | train_error: 13.8 | train_acc: 0.333 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.10% | train_error: 13.8 | train_acc: 0.333 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.20% | train_error: 13.8 | train_acc: 0.333 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.30% | train_error: 14.0 | train_acc: 0.326 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.40% | train_error: 14.0 | train_acc: 0.326 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.50% | train_error: 14.0 | train_acc: 0.326 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.60% | train_error: 14.0 | train_acc: 0.326 | val_error: 13.3 | val_acc: 0.357 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.70% | train_error: 14.1 | train_acc: 0.322 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.80% | train_error: 14.1 | train_acc: 0.322 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.90% | train_error: 14.1 | train_acc: 0.319 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.00% | train_error: 14.1 | train_acc: 0.319 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.10% | train_error: 14.1 | train_acc: 0.319 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.20% | train_error: 14.2 | train_acc: 0.317 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.30% | train_error: 14.2 | train_acc: 0.317 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.40% | train_error: 14.2 | train_acc: 0.317 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.50% | train_error: 14.2 | train_acc: 0.317 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.60% | train_error: 14.3 | train_acc: 0.312 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.70% | train_error: 14.4 | train_acc: 0.308 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.80% | train_error: 14.4 | train_acc: 0.308 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.90% | train_error: 14.4 | train_acc: 0.308 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.00% | train_error: 14.4 | train_acc: 0.308 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.10% | train_error: 14.4 | train_acc: 0.305 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.20% | train_error: 14.4 | train_acc: 0.305 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.30% | train_error: 14.4 | train_acc: 0.305 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.40% | train_error: 14.5 | train_acc: 0.298 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.50% | train_error: 14.5 | train_acc: 0.298 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.60% | train_error: 14.6 | train_acc: 0.296 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.70% | train_error: 14.6 | train_acc: 0.293 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.80% | train_error: 14.7 | train_acc: 0.291 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.90% | train_error: 14.7 | train_acc: 0.291 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.00% | train_error: 14.7 | train_acc: 0.291 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.10% | train_error: 14.7 | train_acc: 0.291 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.20% | train_error: 14.7 | train_acc: 0.291 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.30% | train_error: 14.8 | train_acc: 0.286 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.40% | train_error: 14.8 | train_acc: 0.284 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.50% | train_error: 14.8 | train_acc: 0.284 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.60% | train_error: 14.9 | train_acc: 0.282 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.70% | train_error: 14.9 | train_acc: 0.282 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.80% | train_error: 14.9 | train_acc: 0.282 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.90% | train_error: 14.9 | train_acc: 0.282 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.00% | train_error: 14.9 | train_acc: 0.279 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.10% | train_error: 15.1 | train_acc: 0.272 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.20% | train_error: 15.1 | train_acc: 0.272 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.30% | train_error: 15.1 | train_acc: 0.272 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.40% | train_error: 15.1 | train_acc: 0.270 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.50% | train_error: 15.1 | train_acc: 0.270 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.60% | train_error: 15.4 | train_acc: 0.258 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.70% | train_error: 15.4 | train_acc: 0.258 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.80% | train_error: 15.4 | train_acc: 0.258 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.90% | train_error: 15.4 | train_acc: 0.258 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.00% | train_error: 15.4 | train_acc: 0.258 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.10% | train_error: 15.4 | train_acc: 0.258 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.20% | train_error: 15.3 | train_acc: 0.261 | val_error: 13.9 | val_acc: 0.329 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.30% | train_error: 15.5 | train_acc: 0.254 | val_error: 13.9 | val_acc: 0.329 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.40% | train_error: 15.5 | train_acc: 0.254 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.50% | train_error: 15.5 | train_acc: 0.254 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.60% | train_error: 15.5 | train_acc: 0.254 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.70% | train_error: 15.4 | train_acc: 0.256 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.80% | train_error: 15.4 | train_acc: 0.256 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.90% | train_error: 15.4 | train_acc: 0.256 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.00% | train_error: 15.4 | train_acc: 0.256 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.10% | train_error: 15.6 | train_acc: 0.249 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.20% | train_error: 15.6 | train_acc: 0.249 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.30% | train_error: 15.6 | train_acc: 0.249 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.40% | train_error: 15.7 | train_acc: 0.244 | val_error: 14.3 | val_acc: 0.308 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.50% | train_error: 15.7 | train_acc: 0.242 | val_error: 14.3 | val_acc: 0.308 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.60% | train_error: 15.7 | train_acc: 0.242 | val_error: 14.3 | val_acc: 0.308 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.70% | train_error: 15.7 | train_acc: 0.242 | val_error: 14.5 | val_acc: 0.301 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.80% | train_error: 15.7 | train_acc: 0.242 | val_error: 14.5 | val_acc: 0.301 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.90% | train_error: 15.8 | train_acc: 0.239 | val_error: 14.5 | val_acc: 0.301 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.00% | train_error: 15.9 | train_acc: 0.235 | val_error: 14.5 | val_acc: 0.301 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.10% | train_error: 15.9 | train_acc: 0.235 | val_error: 14.5 | val_acc: 0.301 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.20% | train_error: 15.9 | train_acc: 0.232 | val_error: 14.6 | val_acc: 0.294 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.30% | train_error: 15.9 | train_acc: 0.232 | val_error: 14.6 | val_acc: 0.294 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.40% | train_error: 15.9 | train_acc: 0.232 | val_error: 14.6 | val_acc: 0.294 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.50% | train_error: 15.9 | train_acc: 0.232 | val_error: 14.9 | val_acc: 0.280 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.60% | train_error: 15.9 | train_acc: 0.232 | val_error: 14.8 | val_acc: 0.287 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.70% | train_error: 15.9 | train_acc: 0.232 | val_error: 14.8 | val_acc: 0.287 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.80% | train_error: 16.0 | train_acc: 0.230 | val_error: 14.8 | val_acc: 0.287 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.90% | train_error: 16.0 | train_acc: 0.230 | val_error: 14.9 | val_acc: 0.280 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.00% | train_error: 16.0 | train_acc: 0.230 | val_error: 14.9 | val_acc: 0.280 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.10% | train_error: 16.0 | train_acc: 0.230 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.20% | train_error: 16.0 | train_acc: 0.230 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.30% | train_error: 16.0 | train_acc: 0.230 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.40% | train_error: 16.0 | train_acc: 0.228 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.50% | train_error: 16.0 | train_acc: 0.228 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.60% | train_error: 16.0 | train_acc: 0.228 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.70% | train_error: 16.0 | train_acc: 0.228 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.80% | train_error: 16.0 | train_acc: 0.228 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.90% | train_error: 16.0 | train_acc: 0.228 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.00% | train_error: 16.0 | train_acc: 0.228 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.10% | train_error: 16.0 | train_acc: 0.228 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.20% | train_error: 16.0 | train_acc: 0.228 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.30% | train_error: 16.0 | train_acc: 0.228 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.40% | train_error: 16.0 | train_acc: 0.228 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.50% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.60% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.70% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.80% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.90% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.00% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.10% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.20% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.30% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.40% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.50% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.60% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.70% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.80% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.90% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.00% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.10% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.20% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.30% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.40% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.50% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.60% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.70% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.80% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.90% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.00% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.10% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.20% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.30% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.40% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.50% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.60% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.70% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.80% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.90% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.00% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.10% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.20% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.30% | train_error: 16.0 | train_acc: 0.230 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.40% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.50% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.60% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.70% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.80% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.90% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.00% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.10% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.20% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.30% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.40% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.50% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.60% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.70% | train_error: 15.7 | train_acc: 0.242 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.80% | train_error: 15.7 | train_acc: 0.242 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.90% | train_error: 15.7 | train_acc: 0.242 | val_error: 15.8 | val_acc: 0.238 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.00% | train_error: 15.7 | train_acc: 0.242 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.10% | train_error: 15.7 | train_acc: 0.242 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.20% | train_error: 15.7 | train_acc: 0.242 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.30% | train_error: 15.7 | train_acc: 0.242 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.40% | train_error: 15.7 | train_acc: 0.242 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.50% | train_error: 15.7 | train_acc: 0.242 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.60% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.70% | train_error: 15.5 | train_acc: 0.251 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.80% | train_error: 15.5 | train_acc: 0.251 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.90% | train_error: 15.6 | train_acc: 0.246 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.00% | train_error: 15.6 | train_acc: 0.246 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.10% | train_error: 15.6 | train_acc: 0.246 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.20% | train_error: 15.6 | train_acc: 0.246 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.30% | train_error: 15.6 | train_acc: 0.246 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.40% | train_error: 15.6 | train_acc: 0.246 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.50% | train_error: 15.6 | train_acc: 0.246 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.60% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.70% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.80% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.90% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.00% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.10% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.20% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.30% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.40% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.50% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.60% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.70% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.80% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.90% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.7 | val_acc: 0.245 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.00% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.10% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.20% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.30% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.40% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.50% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.60% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.70% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.80% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.90% | train_error: 15.9 | train_acc: 0.235 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.00% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.10% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.20% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.30% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.40% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.50% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.60% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.70% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.80% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.90% | train_error: 15.8 | train_acc: 0.237 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.00% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.10% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.20% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.5 | val_acc: 0.252 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.30% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.40% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.50% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.60% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.70% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.80% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.90% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.00% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.10% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.20% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.30% | train_error: 15.7 | train_acc: 0.244 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.40% | train_error: 15.6 | train_acc: 0.249 | val_error: 15.4 | val_acc: 0.259 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.50% | train_error: 15.6 | train_acc: 0.249 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.60% | train_error: 15.6 | train_acc: 0.249 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.70% | train_error: 15.6 | train_acc: 0.249 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.80% | train_error: 15.6 | train_acc: 0.249 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.90% | train_error: 15.6 | train_acc: 0.249 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.00% | train_error: 15.6 | train_acc: 0.249 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.10% | train_error: 15.6 | train_acc: 0.249 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.20% | train_error: 15.6 | train_acc: 0.249 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.30% | train_error: 15.6 | train_acc: 0.249 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.40% | train_error: 15.6 | train_acc: 0.249 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.50% | train_error: 15.6 | train_acc: 0.249 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.60% | train_error: 15.4 | train_acc: 0.256 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.70% | train_error: 15.3 | train_acc: 0.261 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.80% | train_error: 15.3 | train_acc: 0.261 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.90% | train_error: 15.4 | train_acc: 0.258 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.00% | train_error: 15.4 | train_acc: 0.258 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.10% | train_error: 15.4 | train_acc: 0.258 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.20% | train_error: 15.4 | train_acc: 0.258 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.30% | train_error: 15.2 | train_acc: 0.268 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.40% | train_error: 15.2 | train_acc: 0.268 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.50% | train_error: 15.2 | train_acc: 0.268 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.60% | train_error: 15.2 | train_acc: 0.268 | val_error: 15.2 | val_acc: 0.266 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.70% | train_error: 15.2 | train_acc: 0.268 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.80% | train_error: 15.2 | train_acc: 0.268 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.90% | train_error: 15.1 | train_acc: 0.272 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.00% | train_error: 15.1 | train_acc: 0.272 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.10% | train_error: 15.1 | train_acc: 0.272 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.20% | train_error: 15.1 | train_acc: 0.272 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.30% | train_error: 15.1 | train_acc: 0.272 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.40% | train_error: 15.1 | train_acc: 0.272 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.50% | train_error: 15.0 | train_acc: 0.277 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.60% | train_error: 15.0 | train_acc: 0.277 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.70% | train_error: 15.0 | train_acc: 0.277 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.80% | train_error: 15.0 | train_acc: 0.277 | val_error: 15.1 | val_acc: 0.273 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.90% | train_error: 15.0 | train_acc: 0.277 | val_error: 14.9 | val_acc: 0.280 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.00% | train_error: 15.0 | train_acc: 0.277 | val_error: 14.9 | val_acc: 0.280 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.10% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.9 | val_acc: 0.280 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.20% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.6 | val_acc: 0.294 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.30% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.5 | val_acc: 0.301 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.40% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.5 | val_acc: 0.301 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.50% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.3 | val_acc: 0.308 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.60% | train_error: 15.0 | train_acc: 0.277 | val_error: 14.3 | val_acc: 0.308 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.70% | train_error: 15.0 | train_acc: 0.277 | val_error: 14.3 | val_acc: 0.308 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.80% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.3 | val_acc: 0.308 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.90% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.00% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.10% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.20% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.30% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.40% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.50% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.60% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.70% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.80% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.90% | train_error: 14.9 | train_acc: 0.279 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.00% | train_error: 14.9 | train_acc: 0.282 | val_error: 14.1 | val_acc: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.10% | train_error: 14.9 | train_acc: 0.282 | val_error: 14.1 | val_acc: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.20% | train_error: 14.9 | train_acc: 0.282 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.30% | train_error: 14.9 | train_acc: 0.282 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.40% | train_error: 14.9 | train_acc: 0.282 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.50% | train_error: 14.9 | train_acc: 0.282 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.60% | train_error: 14.9 | train_acc: 0.282 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.70% | train_error: 14.9 | train_acc: 0.282 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.80% | train_error: 14.9 | train_acc: 0.282 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.90% | train_error: 14.9 | train_acc: 0.282 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.00% | train_error: 14.8 | train_acc: 0.284 | val_error: 14.1 | val_acc: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.10% | train_error: 14.8 | train_acc: 0.284 | val_error: 14.1 | val_acc: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.20% | train_error: 14.7 | train_acc: 0.289 | val_error: 14.1 | val_acc: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.30% | train_error: 14.7 | train_acc: 0.289 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.40% | train_error: 14.7 | train_acc: 0.289 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.50% | train_error: 14.7 | train_acc: 0.289 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.60% | train_error: 14.7 | train_acc: 0.289 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.70% | train_error: 14.7 | train_acc: 0.289 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.80% | train_error: 14.7 | train_acc: 0.289 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.90% | train_error: 14.7 | train_acc: 0.289 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.00% | train_error: 14.7 | train_acc: 0.289 | val_error: 14.2 | val_acc: 0.315 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.10% | train_error: 14.7 | train_acc: 0.291 | val_error: 14.1 | val_acc: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.20% | train_error: 14.6 | train_acc: 0.296 | val_error: 14.1 | val_acc: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.30% | train_error: 14.6 | train_acc: 0.296 | val_error: 14.1 | val_acc: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.40% | train_error: 14.5 | train_acc: 0.300 | val_error: 14.1 | val_acc: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.50% | train_error: 14.5 | train_acc: 0.300 | val_error: 14.1 | val_acc: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.60% | train_error: 14.4 | train_acc: 0.308 | val_error: 14.1 | val_acc: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.70% | train_error: 14.4 | train_acc: 0.308 | val_error: 14.1 | val_acc: 0.322 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.80% | train_error: 14.4 | train_acc: 0.308 | val_error: 13.9 | val_acc: 0.329 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.90% | train_error: 14.4 | train_acc: 0.308 | val_error: 13.9 | val_acc: 0.329 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.00% | train_error: 14.3 | train_acc: 0.310 | val_error: 13.9 | val_acc: 0.329 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.10% | train_error: 14.3 | train_acc: 0.310 | val_error: 13.9 | val_acc: 0.329 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.20% | train_error: 14.3 | train_acc: 0.312 | val_error: 13.9 | val_acc: 0.329 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.30% | train_error: 14.2 | train_acc: 0.315 | val_error: 13.9 | val_acc: 0.329 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.40% | train_error: 14.2 | train_acc: 0.315 | val_error: 13.9 | val_acc: 0.329 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.50% | train_error: 14.2 | train_acc: 0.315 | val_error: 13.9 | val_acc: 0.329 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.60% | train_error: 14.2 | train_acc: 0.315 | val_error: 13.9 | val_acc: 0.329 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.70% | train_error: 14.2 | train_acc: 0.315 | val_error: 13.9 | val_acc: 0.329 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.80% | train_error: 14.1 | train_acc: 0.319 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.90% | train_error: 14.1 | train_acc: 0.319 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.00% | train_error: 14.1 | train_acc: 0.322 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.10% | train_error: 14.1 | train_acc: 0.322 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.20% | train_error: 14.1 | train_acc: 0.322 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.30% | train_error: 14.0 | train_acc: 0.324 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.40% | train_error: 14.0 | train_acc: 0.324 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.50% | train_error: 14.0 | train_acc: 0.324 | val_error: 13.8 | val_acc: 0.336 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.60% | train_error: 14.0 | train_acc: 0.326 | val_error: 13.6 | val_acc: 0.343 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.70% | train_error: 13.9 | train_acc: 0.329 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.80% | train_error: 13.9 | train_acc: 0.329 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.90% | train_error: 13.7 | train_acc: 0.338 | val_error: 13.5 | val_acc: 0.350 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.00% | train_error: 13.6 | train_acc: 0.343 | val_error: 13.3 | val_acc: 0.357 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.10% | train_error: 13.6 | train_acc: 0.343 | val_error: 13.3 | val_acc: 0.357 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.20% | train_error: 13.6 | train_acc: 0.343 | val_error: 13.3 | val_acc: 0.357 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.30% | train_error: 13.6 | train_acc: 0.343 | val_error: 13.3 | val_acc: 0.357 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.40% | train_error: 13.6 | train_acc: 0.343 | val_error: 13.3 | val_acc: 0.357 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.50% | train_error: 13.5 | train_acc: 0.347 | val_error: 13.3 | val_acc: 0.357 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.60% | train_error: 13.5 | train_acc: 0.347 | val_error: 13.3 | val_acc: 0.357 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.70% | train_error: 13.5 | train_acc: 0.347 | val_error: 13.3 | val_acc: 0.357 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.80% | train_error: 13.5 | train_acc: 0.347 | val_error: 13.2 | val_acc: 0.364 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.90% | train_error: 13.4 | train_acc: 0.352 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.00% | train_error: 13.4 | train_acc: 0.352 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.10% | train_error: 13.4 | train_acc: 0.352 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.20% | train_error: 13.4 | train_acc: 0.352 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.30% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.40% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.50% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.60% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.70% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.80% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.90% | train_error: 13.2 | train_acc: 0.362 | val_error: 12.9 | val_acc: 0.378 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.00% | train_error: 13.2 | train_acc: 0.364 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.10% | train_error: 13.2 | train_acc: 0.364 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.20% | train_error: 13.0 | train_acc: 0.373 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.30% | train_error: 13.0 | train_acc: 0.373 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.40% | train_error: 13.0 | train_acc: 0.371 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.50% | train_error: 13.0 | train_acc: 0.371 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.60% | train_error: 13.0 | train_acc: 0.371 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.70% | train_error: 12.8 | train_acc: 0.380 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.80% | train_error: 12.8 | train_acc: 0.383 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.90% | train_error: 12.8 | train_acc: 0.383 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.00% | train_error: 12.8 | train_acc: 0.383 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.10% | train_error: 12.7 | train_acc: 0.385 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.20% | train_error: 12.7 | train_acc: 0.385 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.30% | train_error: 12.7 | train_acc: 0.385 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.40% | train_error: 12.7 | train_acc: 0.385 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.50% | train_error: 12.6 | train_acc: 0.390 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.60% | train_error: 12.6 | train_acc: 0.390 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.70% | train_error: 12.6 | train_acc: 0.390 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.80% | train_error: 12.8 | train_acc: 0.380 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.90% | train_error: 12.8 | train_acc: 0.380 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.00% | train_error: 12.8 | train_acc: 0.380 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.10% | train_error: 12.8 | train_acc: 0.380 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.20% | train_error: 12.8 | train_acc: 0.383 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.30% | train_error: 12.8 | train_acc: 0.383 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.40% | train_error: 12.8 | train_acc: 0.383 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.50% | train_error: 12.8 | train_acc: 0.383 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.60% | train_error: 12.6 | train_acc: 0.390 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.70% | train_error: 12.6 | train_acc: 0.390 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.80% | train_error: 12.6 | train_acc: 0.390 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.90% | train_error: 12.6 | train_acc: 0.390 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.00% | train_error: 12.6 | train_acc: 0.390 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.10% | train_error: 12.6 | train_acc: 0.390 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.20% | train_error: 12.6 | train_acc: 0.392 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.30% | train_error: 12.6 | train_acc: 0.392 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.40% | train_error: 12.6 | train_acc: 0.394 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.50% | train_error: 12.6 | train_acc: 0.394 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.60% | train_error: 12.6 | train_acc: 0.394 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.70% | train_error: 12.6 | train_acc: 0.394 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.80% | train_error: 12.6 | train_acc: 0.394 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.90% | train_error: 12.6 | train_acc: 0.394 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.00% | train_error: 12.6 | train_acc: 0.394 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.10% | train_error: 12.5 | train_acc: 0.397 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.20% | train_error: 12.5 | train_acc: 0.397 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.30% | train_error: 12.5 | train_acc: 0.397 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.40% | train_error: 12.5 | train_acc: 0.397 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.50% | train_error: 12.5 | train_acc: 0.397 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.60% | train_error: 12.4 | train_acc: 0.401 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.70% | train_error: 12.4 | train_acc: 0.404 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.80% | train_error: 12.2 | train_acc: 0.411 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.90% | train_error: 12.1 | train_acc: 0.415 | val_error: 12.2 | val_acc: 0.413 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.00% | train_error: 12.1 | train_acc: 0.415 | val_error: 12.0 | val_acc: 0.420 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.10% | train_error: 12.1 | train_acc: 0.415 | val_error: 12.0 | val_acc: 0.420 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.20% | train_error: 12.1 | train_acc: 0.415 | val_error: 12.0 | val_acc: 0.420 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.30% | train_error: 12.1 | train_acc: 0.418 | val_error: 12.2 | val_acc: 0.413 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.40% | train_error: 11.7 | train_acc: 0.437 | val_error: 12.0 | val_acc: 0.420 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.50% | train_error: 11.7 | train_acc: 0.434 | val_error: 12.0 | val_acc: 0.420 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.60% | train_error: 11.7 | train_acc: 0.434 | val_error: 12.0 | val_acc: 0.420 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.70% | train_error: 11.7 | train_acc: 0.437 | val_error: 12.0 | val_acc: 0.420 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.80% | train_error: 11.7 | train_acc: 0.437 | val_error: 11.9 | val_acc: 0.427 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.90% | train_error: 11.7 | train_acc: 0.437 | val_error: 11.9 | val_acc: 0.427 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.00% | train_error: 11.7 | train_acc: 0.437 | val_error: 11.9 | val_acc: 0.427 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.10% | train_error: 11.7 | train_acc: 0.437 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.20% | train_error: 11.7 | train_acc: 0.437 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.30% | train_error: 11.7 | train_acc: 0.437 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.40% | train_error: 11.5 | train_acc: 0.444 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.50% | train_error: 11.5 | train_acc: 0.444 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.60% | train_error: 11.6 | train_acc: 0.441 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.70% | train_error: 11.3 | train_acc: 0.453 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.80% | train_error: 11.3 | train_acc: 0.453 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.90% | train_error: 11.3 | train_acc: 0.453 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.00% | train_error: 11.3 | train_acc: 0.453 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.10% | train_error: 11.3 | train_acc: 0.453 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.20% | train_error: 11.3 | train_acc: 0.453 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.30% | train_error: 11.3 | train_acc: 0.453 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.40% | train_error: 11.3 | train_acc: 0.453 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.50% | train_error: 11.4 | train_acc: 0.451 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.60% | train_error: 11.4 | train_acc: 0.451 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.70% | train_error: 11.4 | train_acc: 0.451 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.80% | train_error: 11.4 | train_acc: 0.451 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.90% | train_error: 11.3 | train_acc: 0.455 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.00% | train_error: 11.2 | train_acc: 0.460 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.10% | train_error: 10.9 | train_acc: 0.472 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.20% | train_error: 10.9 | train_acc: 0.472 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.30% | train_error: 10.9 | train_acc: 0.472 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.40% | train_error: 10.9 | train_acc: 0.472 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.50% | train_error: 10.9 | train_acc: 0.472 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.60% | train_error: 10.9 | train_acc: 0.472 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.70% | train_error: 10.8 | train_acc: 0.477 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.80% | train_error: 10.8 | train_acc: 0.477 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.90% | train_error: 10.8 | train_acc: 0.477 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.00% | train_error: 10.7 | train_acc: 0.484 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.10% | train_error: 10.7 | train_acc: 0.484 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.20% | train_error: 10.7 | train_acc: 0.486 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.30% | train_error: 10.7 | train_acc: 0.486 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.40% | train_error: 10.7 | train_acc: 0.486 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.50% | train_error: 10.7 | train_acc: 0.486 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.60% | train_error: 10.7 | train_acc: 0.486 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.70% | train_error: 10.6 | train_acc: 0.488 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.80% | train_error: 10.6 | train_acc: 0.488 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.90% | train_error: 10.6 | train_acc: 0.491 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.00% | train_error: 10.5 | train_acc: 0.493 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.10% | train_error: 10.5 | train_acc: 0.493 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.20% | train_error: 10.5 | train_acc: 0.493 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.30% | train_error: 10.5 | train_acc: 0.493 | val_error: 11.0 | val_acc: 0.469 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.40% | train_error: 10.5 | train_acc: 0.493 | val_error: 11.0 | val_acc: 0.469 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.50% | train_error: 10.5 | train_acc: 0.493 | val_error: 11.0 | val_acc: 0.469 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.60% | train_error: 10.3 | train_acc: 0.502 | val_error: 11.0 | val_acc: 0.469 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.70% | train_error: 10.3 | train_acc: 0.502 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.80% | train_error: 10.3 | train_acc: 0.502 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.90% | train_error: 10.3 | train_acc: 0.502 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.00% | train_error: 10.2 | train_acc: 0.507 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.10% | train_error: 10.2 | train_acc: 0.507 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.20% | train_error: 10.2 | train_acc: 0.509 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.30% | train_error: 10.2 | train_acc: 0.509 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.40% | train_error: 10.2 | train_acc: 0.509 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.50% | train_error: 10.2 | train_acc: 0.509 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.60% | train_error: 10.1 | train_acc: 0.512 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.70% | train_error: 10.1 | train_acc: 0.512 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.80% | train_error: 10.1 | train_acc: 0.512 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.90% | train_error: 10.1 | train_acc: 0.512 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.00% | train_error: 10.0 | train_acc: 0.516 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.10% | train_error: 9.97 | train_acc: 0.519 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.20% | train_error: 9.97 | train_acc: 0.519 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.30% | train_error: 9.88 | train_acc: 0.523 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.40% | train_error: 9.88 | train_acc: 0.523 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.50% | train_error: 9.78 | train_acc: 0.528 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.60% | train_error: 9.68 | train_acc: 0.533 | val_error: 10.3 | val_acc: 0.503 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.70% | train_error: 9.68 | train_acc: 0.533 | val_error: 10.00 | val_acc: 0.517 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.80% | train_error: 9.53 | train_acc: 0.540 | val_error: 10.00 | val_acc: 0.517 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.90% | train_error: 9.44 | train_acc: 0.545 | val_error: 10.00 | val_acc: 0.517 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.00% | train_error: 9.39 | train_acc: 0.547 | val_error: 10.00 | val_acc: 0.517 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.10% | train_error: 9.29 | train_acc: 0.552 | val_error: 10.00 | val_acc: 0.517 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.20% | train_error: 9.29 | train_acc: 0.552 | val_error: 10.00 | val_acc: 0.517 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.30% | train_error: 9.24 | train_acc: 0.554 | val_error: 9.85 | val_acc: 0.524 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.40% | train_error: 9.24 | train_acc: 0.554 | val_error: 9.85 | val_acc: 0.524 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.50% | train_error: 8.85 | train_acc: 0.573 | val_error: 9.85 | val_acc: 0.524 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.60% | train_error: 8.85 | train_acc: 0.573 | val_error: 9.85 | val_acc: 0.524 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.70% | train_error: 8.76 | train_acc: 0.577 | val_error: 9.56 | val_acc: 0.538 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.80% | train_error: 8.76 | train_acc: 0.577 | val_error: 9.56 | val_acc: 0.538 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.90% | train_error: 8.76 | train_acc: 0.577 | val_error: 9.56 | val_acc: 0.538 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.00% | train_error: 8.76 | train_acc: 0.577 | val_error: 9.56 | val_acc: 0.538 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.10% | train_error: 8.71 | train_acc: 0.580 | val_error: 9.56 | val_acc: 0.538 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.20% | train_error: 8.71 | train_acc: 0.580 | val_error: 9.42 | val_acc: 0.545 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.30% | train_error: 8.71 | train_acc: 0.580 | val_error: 9.42 | val_acc: 0.545 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.40% | train_error: 8.56 | train_acc: 0.587 | val_error: 9.42 | val_acc: 0.545 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.50% | train_error: 8.56 | train_acc: 0.587 | val_error: 9.42 | val_acc: 0.545 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.60% | train_error: 8.51 | train_acc: 0.589 | val_error: 9.42 | val_acc: 0.545 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.70% | train_error: 8.46 | train_acc: 0.592 | val_error: 9.42 | val_acc: 0.545 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.80% | train_error: 8.32 | train_acc: 0.599 | val_error: 9.42 | val_acc: 0.545 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.90% | train_error: 8.22 | train_acc: 0.603 | val_error: 9.42 | val_acc: 0.545 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.00% | train_error: 8.12 | train_acc: 0.608 | val_error: 9.42 | val_acc: 0.545 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.10% | train_error: 8.08 | train_acc: 0.610 | val_error: 9.27 | val_acc: 0.552 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.20% | train_error: 8.03 | train_acc: 0.613 | val_error: 9.27 | val_acc: 0.552 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.30% | train_error: 8.03 | train_acc: 0.613 | val_error: 9.27 | val_acc: 0.552 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.40% | train_error: 8.03 | train_acc: 0.613 | val_error: 9.13 | val_acc: 0.559 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.50% | train_error: 8.03 | train_acc: 0.613 | val_error: 9.13 | val_acc: 0.559 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.60% | train_error: 8.03 | train_acc: 0.613 | val_error: 8.98 | val_acc: 0.566 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.70% | train_error: 8.03 | train_acc: 0.613 | val_error: 8.98 | val_acc: 0.566 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.80% | train_error: 8.03 | train_acc: 0.613 | val_error: 8.84 | val_acc: 0.573 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.90% | train_error: 7.98 | train_acc: 0.615 | val_error: 8.70 | val_acc: 0.580 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.00% | train_error: 7.98 | train_acc: 0.615 | val_error: 8.55 | val_acc: 0.587 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.10% | train_error: 7.88 | train_acc: 0.620 | val_error: 8.55 | val_acc: 0.587 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.20% | train_error: 7.88 | train_acc: 0.620 | val_error: 8.55 | val_acc: 0.587 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.30% | train_error: 7.88 | train_acc: 0.620 | val_error: 8.70 | val_acc: 0.580 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.40% | train_error: 7.88 | train_acc: 0.620 | val_error: 8.70 | val_acc: 0.580 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.50% | train_error: 7.88 | train_acc: 0.620 | val_error: 8.70 | val_acc: 0.580 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.60% | train_error: 7.73 | train_acc: 0.627 | val_error: 8.70 | val_acc: 0.580 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.70% | train_error: 7.73 | train_acc: 0.627 | val_error: 8.70 | val_acc: 0.580 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.80% | train_error: 7.73 | train_acc: 0.627 | val_error: 8.70 | val_acc: 0.580 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.90% | train_error: 7.73 | train_acc: 0.627 | val_error: 8.70 | val_acc: 0.580 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.00% | train_error: 7.69 | train_acc: 0.629 | val_error: 8.55 | val_acc: 0.587 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.10% | train_error: 7.69 | train_acc: 0.629 | val_error: 8.55 | val_acc: 0.587 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.20% | train_error: 7.69 | train_acc: 0.629 | val_error: 8.41 | val_acc: 0.594 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.30% | train_error: 7.69 | train_acc: 0.629 | val_error: 8.41 | val_acc: 0.594 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.40% | train_error: 7.69 | train_acc: 0.629 | val_error: 8.26 | val_acc: 0.601 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.50% | train_error: 7.69 | train_acc: 0.629 | val_error: 8.12 | val_acc: 0.608 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.60% | train_error: 7.69 | train_acc: 0.629 | val_error: 8.12 | val_acc: 0.608 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.70% | train_error: 7.69 | train_acc: 0.629 | val_error: 7.97 | val_acc: 0.615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.80% | train_error: 7.54 | train_acc: 0.636 | val_error: 7.97 | val_acc: 0.615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.90% | train_error: 7.54 | train_acc: 0.636 | val_error: 7.97 | val_acc: 0.615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.00% | train_error: 7.54 | train_acc: 0.636 | val_error: 7.97 | val_acc: 0.615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.10% | train_error: 7.44 | train_acc: 0.641 | val_error: 7.97 | val_acc: 0.615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.20% | train_error: 7.44 | train_acc: 0.641 | val_error: 7.97 | val_acc: 0.615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.30% | train_error: 7.30 | train_acc: 0.648 | val_error: 7.97 | val_acc: 0.615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.40% | train_error: 7.30 | train_acc: 0.648 | val_error: 7.97 | val_acc: 0.615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.50% | train_error: 7.30 | train_acc: 0.648 | val_error: 7.83 | val_acc: 0.622 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.60% | train_error: 7.10 | train_acc: 0.657 | val_error: 7.83 | val_acc: 0.622 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.70% | train_error: 7.01 | train_acc: 0.662 | val_error: 7.83 | val_acc: 0.622 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.80% | train_error: 6.91 | train_acc: 0.667 | val_error: 7.97 | val_acc: 0.615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.90% | train_error: 6.91 | train_acc: 0.667 | val_error: 7.97 | val_acc: 0.615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.00% | train_error: 6.81 | train_acc: 0.671 | val_error: 7.83 | val_acc: 0.622 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.10% | train_error: 6.81 | train_acc: 0.671 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.20% | train_error: 6.81 | train_acc: 0.671 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.30% | train_error: 6.81 | train_acc: 0.671 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.40% | train_error: 6.76 | train_acc: 0.674 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.50% | train_error: 6.76 | train_acc: 0.674 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.60% | train_error: 6.71 | train_acc: 0.676 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.70% | train_error: 6.71 | train_acc: 0.676 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.80% | train_error: 6.71 | train_acc: 0.676 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.90% | train_error: 6.71 | train_acc: 0.676 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.00% | train_error: 6.91 | train_acc: 0.667 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.10% | train_error: 6.91 | train_acc: 0.667 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.20% | train_error: 6.86 | train_acc: 0.669 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.30% | train_error: 6.86 | train_acc: 0.669 | val_error: 7.68 | val_acc: 0.629 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.40% | train_error: 6.86 | train_acc: 0.669 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.50% | train_error: 6.71 | train_acc: 0.676 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.60% | train_error: 6.71 | train_acc: 0.676 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.70% | train_error: 6.71 | train_acc: 0.676 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.80% | train_error: 6.71 | train_acc: 0.676 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.90% | train_error: 6.71 | train_acc: 0.676 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.00% | train_error: 6.71 | train_acc: 0.676 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.10% | train_error: 6.66 | train_acc: 0.678 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.20% | train_error: 6.57 | train_acc: 0.683 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.30% | train_error: 6.57 | train_acc: 0.683 | val_error: 7.39 | val_acc: 0.643 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.40% | train_error: 6.57 | train_acc: 0.683 | val_error: 7.39 | val_acc: 0.643 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.50% | train_error: 6.57 | train_acc: 0.683 | val_error: 7.39 | val_acc: 0.643 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.60% | train_error: 6.57 | train_acc: 0.683 | val_error: 7.39 | val_acc: 0.643 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.70% | train_error: 6.57 | train_acc: 0.683 | val_error: 7.25 | val_acc: 0.650 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.80% | train_error: 6.52 | train_acc: 0.685 | val_error: 7.25 | val_acc: 0.650 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.90% | train_error: 6.52 | train_acc: 0.685 | val_error: 7.25 | val_acc: 0.650 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.00% | train_error: 6.52 | train_acc: 0.685 | val_error: 7.25 | val_acc: 0.650 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.10% | train_error: 6.52 | train_acc: 0.685 | val_error: 7.25 | val_acc: 0.650 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.20% | train_error: 6.47 | train_acc: 0.688 | val_error: 7.25 | val_acc: 0.650 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.30% | train_error: 6.42 | train_acc: 0.690 | val_error: 7.10 | val_acc: 0.657 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.40% | train_error: 6.42 | train_acc: 0.690 | val_error: 7.10 | val_acc: 0.657 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.50% | train_error: 6.42 | train_acc: 0.690 | val_error: 7.10 | val_acc: 0.657 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.60% | train_error: 6.42 | train_acc: 0.690 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.70% | train_error: 6.37 | train_acc: 0.692 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.80% | train_error: 6.32 | train_acc: 0.695 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.90% | train_error: 6.32 | train_acc: 0.695 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.00% | train_error: 6.32 | train_acc: 0.695 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.10% | train_error: 6.32 | train_acc: 0.695 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.20% | train_error: 6.32 | train_acc: 0.695 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.30% | train_error: 6.32 | train_acc: 0.695 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.40% | train_error: 6.32 | train_acc: 0.695 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.50% | train_error: 6.23 | train_acc: 0.700 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.60% | train_error: 6.23 | train_acc: 0.700 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.70% | train_error: 6.23 | train_acc: 0.700 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.80% | train_error: 6.23 | train_acc: 0.700 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.90% | train_error: 6.18 | train_acc: 0.702 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.00% | train_error: 5.98 | train_acc: 0.711 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.10% | train_error: 5.93 | train_acc: 0.714 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.20% | train_error: 5.84 | train_acc: 0.718 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.30% | train_error: 5.84 | train_acc: 0.718 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.40% | train_error: 5.84 | train_acc: 0.718 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.50% | train_error: 5.79 | train_acc: 0.721 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.60% | train_error: 5.64 | train_acc: 0.728 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.70% | train_error: 5.64 | train_acc: 0.728 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.80% | train_error: 5.59 | train_acc: 0.730 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.90% | train_error: 5.59 | train_acc: 0.730 | val_error: 6.38 | val_acc: 0.692 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.00% | train_error: 5.59 | train_acc: 0.730 | val_error: 6.38 | val_acc: 0.692 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.10% | train_error: 5.50 | train_acc: 0.735 | val_error: 6.23 | val_acc: 0.699 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.20% | train_error: 5.30 | train_acc: 0.744 | val_error: 6.23 | val_acc: 0.699 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.30% | train_error: 5.30 | train_acc: 0.744 | val_error: 6.23 | val_acc: 0.699 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.40% | train_error: 5.30 | train_acc: 0.744 | val_error: 6.23 | val_acc: 0.699 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.50% | train_error: 5.16 | train_acc: 0.751 | val_error: 6.23 | val_acc: 0.699 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.60% | train_error: 5.11 | train_acc: 0.754 | val_error: 6.09 | val_acc: 0.706 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.70% | train_error: 5.06 | train_acc: 0.756 | val_error: 5.94 | val_acc: 0.713 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.80% | train_error: 5.06 | train_acc: 0.756 | val_error: 5.94 | val_acc: 0.713 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.90% | train_error: 5.06 | train_acc: 0.756 | val_error: 5.94 | val_acc: 0.713 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.00% | train_error: 5.06 | train_acc: 0.756 | val_error: 5.94 | val_acc: 0.713 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.10% | train_error: 5.01 | train_acc: 0.758 | val_error: 5.94 | val_acc: 0.713 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.20% | train_error: 5.01 | train_acc: 0.758 | val_error: 5.94 | val_acc: 0.713 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.30% | train_error: 4.91 | train_acc: 0.763 | val_error: 5.80 | val_acc: 0.720 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.40% | train_error: 4.91 | train_acc: 0.763 | val_error: 5.80 | val_acc: 0.720 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.50% | train_error: 4.91 | train_acc: 0.763 | val_error: 5.80 | val_acc: 0.720 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.60% | train_error: 4.91 | train_acc: 0.763 | val_error: 5.80 | val_acc: 0.720 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.70% | train_error: 4.91 | train_acc: 0.763 | val_error: 5.80 | val_acc: 0.720 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.80% | train_error: 4.91 | train_acc: 0.763 | val_error: 5.80 | val_acc: 0.720 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.90% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.80 | val_acc: 0.720 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.00% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.80 | val_acc: 0.720 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.10% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.80 | val_acc: 0.720 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.20% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.65 | val_acc: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.30% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.65 | val_acc: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.40% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.65 | val_acc: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.50% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.65 | val_acc: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.60% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.65 | val_acc: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.70% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.36 | val_acc: 0.741 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.80% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.36 | val_acc: 0.741 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.90% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.36 | val_acc: 0.741 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.00% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.36 | val_acc: 0.741 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.10% | train_error: 4.67 | train_acc: 0.775 | val_error: 5.36 | val_acc: 0.741 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.20% | train_error: 4.62 | train_acc: 0.777 | val_error: 5.36 | val_acc: 0.741 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.30% | train_error: 4.57 | train_acc: 0.779 | val_error: 5.22 | val_acc: 0.748 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.40% | train_error: 4.57 | train_acc: 0.779 | val_error: 5.22 | val_acc: 0.748 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.50% | train_error: 4.57 | train_acc: 0.779 | val_error: 5.22 | val_acc: 0.748 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.60% | train_error: 4.57 | train_acc: 0.779 | val_error: 5.22 | val_acc: 0.748 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.70% | train_error: 4.57 | train_acc: 0.779 | val_error: 5.22 | val_acc: 0.748 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.80% | train_error: 4.57 | train_acc: 0.779 | val_error: 5.22 | val_acc: 0.748 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.90% | train_error: 4.57 | train_acc: 0.779 | val_error: 5.07 | val_acc: 0.755 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.00% | train_error: 4.52 | train_acc: 0.782 | val_error: 5.07 | val_acc: 0.755 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.10% | train_error: 4.52 | train_acc: 0.782 | val_error: 4.93 | val_acc: 0.762 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.20% | train_error: 4.43 | train_acc: 0.786 | val_error: 4.78 | val_acc: 0.769 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.30% | train_error: 4.38 | train_acc: 0.789 | val_error: 4.78 | val_acc: 0.769 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.40% | train_error: 4.13 | train_acc: 0.800 | val_error: 4.78 | val_acc: 0.769 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.50% | train_error: 4.13 | train_acc: 0.800 | val_error: 4.78 | val_acc: 0.769 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.60% | train_error: 4.13 | train_acc: 0.800 | val_error: 4.78 | val_acc: 0.769 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.70% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.78 | val_acc: 0.769 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.80% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.78 | val_acc: 0.769 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.90% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.64 | val_acc: 0.776 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.00% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.64 | val_acc: 0.776 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.10% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.49 | val_acc: 0.783 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.20% | train_error: 4.04 | train_acc: 0.805 | val_error: 4.49 | val_acc: 0.783 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.30% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.49 | val_acc: 0.783 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.40% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.49 | val_acc: 0.783 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.50% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.35 | val_acc: 0.790 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.60% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.35 | val_acc: 0.790 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.70% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.35 | val_acc: 0.790 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.80% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.35 | val_acc: 0.790 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.90% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.35 | val_acc: 0.790 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.00% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.10% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.20% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.30% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.40% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.50% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.60% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.70% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.80% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.90% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.00% | train_error: 4.28 | train_acc: 0.793 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.10% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.20% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.30% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.40% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.50% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.60% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.70% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.80% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.90% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.00% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.10% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.20% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.30% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.40% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.50% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.60% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.70% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.80% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.90% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.00% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.10% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.20% | train_error: 4.33 | train_acc: 0.791 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.30% | train_error: 4.33 | train_acc: 0.791 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.40% | train_error: 4.33 | train_acc: 0.791 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.50% | train_error: 4.33 | train_acc: 0.791 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.60% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.70% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.80% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.90% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.00% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.10% | train_error: 4.23 | train_acc: 0.796 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.20% | train_error: 4.18 | train_acc: 0.798 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.30% | train_error: 4.18 | train_acc: 0.798 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.40% | train_error: 4.18 | train_acc: 0.798 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.50% | train_error: 4.18 | train_acc: 0.798 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.60% | train_error: 4.13 | train_acc: 0.800 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.70% | train_error: 4.13 | train_acc: 0.800 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.80% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.90% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.00% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.10% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.20% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.30% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.40% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.50% | train_error: 4.09 | train_acc: 0.803 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.60% | train_error: 4.04 | train_acc: 0.805 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.70% | train_error: 4.04 | train_acc: 0.805 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.80% | train_error: 4.04 | train_acc: 0.805 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.90% | train_error: 3.99 | train_acc: 0.808 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.00% | train_error: 3.89 | train_acc: 0.812 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.10% | train_error: 3.89 | train_acc: 0.812 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.20% | train_error: 3.89 | train_acc: 0.812 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.30% | train_error: 3.89 | train_acc: 0.812 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.40% | train_error: 3.79 | train_acc: 0.817 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.50% | train_error: 3.79 | train_acc: 0.817 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.60% | train_error: 3.89 | train_acc: 0.812 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.70% | train_error: 3.84 | train_acc: 0.815 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.80% | train_error: 3.84 | train_acc: 0.815 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.90% | train_error: 3.84 | train_acc: 0.815 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.00% | train_error: 3.84 | train_acc: 0.815 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.10% | train_error: 3.84 | train_acc: 0.815 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.20% | train_error: 3.84 | train_acc: 0.815 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.30% | train_error: 3.84 | train_acc: 0.815 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.40% | train_error: 3.84 | train_acc: 0.815 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.50% | train_error: 3.70 | train_acc: 0.822 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.60% | train_error: 3.70 | train_acc: 0.822 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.70% | train_error: 3.70 | train_acc: 0.822 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.80% | train_error: 3.70 | train_acc: 0.822 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.90% | train_error: 3.70 | train_acc: 0.822 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.00% | train_error: 3.70 | train_acc: 0.822 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.10% | train_error: 3.70 | train_acc: 0.822 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.20% | train_error: 3.70 | train_acc: 0.822 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.30% | train_error: 3.70 | train_acc: 0.822 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.40% | train_error: 3.70 | train_acc: 0.822 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.50% | train_error: 3.70 | train_acc: 0.822 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.60% | train_error: 3.70 | train_acc: 0.822 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.70% | train_error: 3.70 | train_acc: 0.822 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.80% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.90% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.00% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.10% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.20% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.30% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.40% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.50% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.60% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.70% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.80% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.90% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.00% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.10% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.20% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.30% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.40% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.50% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.60% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.70% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.80% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.90% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.00% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.10% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.20% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.30% | train_error: 3.60 | train_acc: 0.826 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.40% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.50% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.60% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.70% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.80% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.90% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.00% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.10% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.20% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.30% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.40% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.50% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.60% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.70% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.80% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.90% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.00% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.10% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.20% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.30% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.40% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.50% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.60% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.70% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.80% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.90% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.00% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.10% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.20% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.30% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.40% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.50% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.60% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.70% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.80% | train_error: 3.65 | train_acc: 0.824 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.90% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.00% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.10% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.20% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.30% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.40% | train_error: 3.55 | train_acc: 0.829 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.50% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.60% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.70% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.80% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.90% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.00% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.10% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.20% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.30% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.40% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.50% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.60% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.70% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.80% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.90% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.00% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.10% | train_error: 3.50 | train_acc: 0.831 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.20% | train_error: 3.45 | train_acc: 0.833 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.30% | train_error: 3.45 | train_acc: 0.833 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.40% | train_error: 3.41 | train_acc: 0.836 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.50% | train_error: 3.36 | train_acc: 0.838 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.60% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.70% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.80% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.90% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.00% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.10% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.20% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.30% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.40% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.50% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.60% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.70% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.80% | train_error: 3.26 | train_acc: 0.843 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.90% | train_error: 3.21 | train_acc: 0.845 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================================>] 100.0% | train_error: 3.21 | train_acc: 0.845 | val_error: 3.77 | val_acc: 0.818 " ] } ], "source": [ "logistic_regression.reset_weights() # reset weights such that previous runs or reruns don't affect the weights\n", "\n", "scheduler = Adam(eta=1e-3, rho=0.9, rho2=0.999)\n", "scores = logistic_regression.fit(X_train, t_train, scheduler, epochs=1000, X_val=X_val, t_val=t_val)" ] }, { "cell_type": "markdown", "id": "ae0148bb", "metadata": {}, "source": [ "Finally, we will create a neural network with 2 hidden layers with activation functions." ] }, { "cell_type": "code", "execution_count": 18, "id": "bb7e4340", "metadata": {}, "outputs": [], "source": [ "input_nodes = X_train.shape[1]\n", "hidden_nodes1 = 100\n", "hidden_nodes2 = 30\n", "output_nodes = 1\n", "\n", "dims = (input_nodes, hidden_nodes1, hidden_nodes2, output_nodes)\n", "\n", "neural_network = FFNN(dims, hidden_func=RELU, output_func=sigmoid, cost_func=CostLogReg, seed=2023)" ] }, { "cell_type": "code", "execution_count": 19, "id": "d0655afb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Adam: Eta=0.0001, Lambda=0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.000% | train_error: 11.3 | train_acc: 0.453 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.1000% | train_error: 11.4 | train_acc: 0.448 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.2000% | train_error: 11.4 | train_acc: 0.448 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.3000% | train_error: 11.4 | train_acc: 0.448 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.4000% | train_error: 11.4 | train_acc: 0.448 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.5000% | train_error: 11.4 | train_acc: 0.448 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.6000% | train_error: 11.4 | train_acc: 0.448 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.7000% | train_error: 11.5 | train_acc: 0.444 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.8000% | train_error: 11.5 | train_acc: 0.444 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.9000% | train_error: 11.3 | train_acc: 0.453 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.000% | train_error: 11.3 | train_acc: 0.453 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.100% | train_error: 11.3 | train_acc: 0.453 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.200% | train_error: 11.3 | train_acc: 0.453 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.300% | train_error: 11.3 | train_acc: 0.453 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.400% | train_error: 11.4 | train_acc: 0.448 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.500% | train_error: 11.4 | train_acc: 0.451 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.600% | train_error: 11.5 | train_acc: 0.444 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.700% | train_error: 11.5 | train_acc: 0.444 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.800% | train_error: 11.6 | train_acc: 0.441 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.900% | train_error: 11.6 | train_acc: 0.441 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.000% | train_error: 11.6 | train_acc: 0.441 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.100% | train_error: 11.6 | train_acc: 0.439 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.200% | train_error: 11.6 | train_acc: 0.439 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.300% | train_error: 11.8 | train_acc: 0.430 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.400% | train_error: 11.9 | train_acc: 0.425 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.500% | train_error: 11.9 | train_acc: 0.425 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.600% | train_error: 11.9 | train_acc: 0.427 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.700% | train_error: 11.9 | train_acc: 0.427 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.800% | train_error: 11.9 | train_acc: 0.427 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.900% | train_error: 11.9 | train_acc: 0.427 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.000% | train_error: 11.9 | train_acc: 0.427 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.100% | train_error: 11.9 | train_acc: 0.427 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.200% | train_error: 11.9 | train_acc: 0.427 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.300% | train_error: 11.9 | train_acc: 0.425 | val_error: 10.9 | val_acc: 0.476 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.400% | train_error: 11.9 | train_acc: 0.427 | val_error: 10.9 | val_acc: 0.476 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.500% | train_error: 11.9 | train_acc: 0.427 | val_error: 11.0 | val_acc: 0.469 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.600% | train_error: 11.8 | train_acc: 0.432 | val_error: 11.0 | val_acc: 0.469 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.700% | train_error: 11.6 | train_acc: 0.439 | val_error: 11.0 | val_acc: 0.469 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.800% | train_error: 11.6 | train_acc: 0.439 | val_error: 11.0 | val_acc: 0.469 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.900% | train_error: 11.7 | train_acc: 0.434 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.000% | train_error: 11.7 | train_acc: 0.434 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.100% | train_error: 11.8 | train_acc: 0.430 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.200% | train_error: 11.9 | train_acc: 0.425 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.300% | train_error: 12.0 | train_acc: 0.423 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.400% | train_error: 11.9 | train_acc: 0.427 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.500% | train_error: 11.8 | train_acc: 0.430 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.600% | train_error: 11.8 | train_acc: 0.432 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.700% | train_error: 11.8 | train_acc: 0.430 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.800% | train_error: 11.7 | train_acc: 0.434 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.900% | train_error: 11.5 | train_acc: 0.446 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.000% | train_error: 11.5 | train_acc: 0.446 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.100% | train_error: 11.5 | train_acc: 0.446 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.200% | train_error: 11.5 | train_acc: 0.446 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.300% | train_error: 11.5 | train_acc: 0.444 | val_error: 11.0 | val_acc: 0.469 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.400% | train_error: 11.5 | train_acc: 0.444 | val_error: 11.0 | val_acc: 0.469 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.500% | train_error: 11.5 | train_acc: 0.444 | val_error: 11.0 | val_acc: 0.469 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.600% | train_error: 11.5 | train_acc: 0.444 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.700% | train_error: 11.5 | train_acc: 0.444 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.800% | train_error: 11.9 | train_acc: 0.425 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.900% | train_error: 11.9 | train_acc: 0.425 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.000% | train_error: 12.0 | train_acc: 0.420 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.100% | train_error: 12.0 | train_acc: 0.420 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.200% | train_error: 12.1 | train_acc: 0.418 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.300% | train_error: 12.1 | train_acc: 0.418 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.400% | train_error: 11.9 | train_acc: 0.425 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.500% | train_error: 11.9 | train_acc: 0.427 | val_error: 11.9 | val_acc: 0.427 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.600% | train_error: 11.8 | train_acc: 0.432 | val_error: 12.0 | val_acc: 0.420 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.700% | train_error: 11.5 | train_acc: 0.444 | val_error: 12.2 | val_acc: 0.413 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.800% | train_error: 11.4 | train_acc: 0.448 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.900% | train_error: 11.2 | train_acc: 0.458 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.000% | train_error: 11.2 | train_acc: 0.458 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.100% | train_error: 11.3 | train_acc: 0.455 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.200% | train_error: 11.3 | train_acc: 0.455 | val_error: 12.6 | val_acc: 0.392 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.300% | train_error: 11.3 | train_acc: 0.455 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.400% | train_error: 11.3 | train_acc: 0.453 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.500% | train_error: 11.3 | train_acc: 0.455 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.600% | train_error: 11.5 | train_acc: 0.446 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.700% | train_error: 11.3 | train_acc: 0.453 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.800% | train_error: 11.4 | train_acc: 0.448 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.900% | train_error: 11.4 | train_acc: 0.448 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.000% | train_error: 11.4 | train_acc: 0.451 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.100% | train_error: 11.4 | train_acc: 0.448 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.200% | train_error: 11.3 | train_acc: 0.453 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.300% | train_error: 11.3 | train_acc: 0.453 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.400% | train_error: 11.4 | train_acc: 0.451 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.500% | train_error: 11.4 | train_acc: 0.451 | val_error: 12.5 | val_acc: 0.399 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.600% | train_error: 11.4 | train_acc: 0.451 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.700% | train_error: 11.2 | train_acc: 0.458 | val_error: 12.3 | val_acc: 0.406 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.800% | train_error: 11.2 | train_acc: 0.458 | val_error: 12.2 | val_acc: 0.413 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.900% | train_error: 11.2 | train_acc: 0.458 | val_error: 12.0 | val_acc: 0.420 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.000% | train_error: 11.2 | train_acc: 0.458 | val_error: 12.0 | val_acc: 0.420 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.100% | train_error: 11.2 | train_acc: 0.458 | val_error: 11.9 | val_acc: 0.427 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.200% | train_error: 11.2 | train_acc: 0.458 | val_error: 11.9 | val_acc: 0.427 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.300% | train_error: 11.2 | train_acc: 0.460 | val_error: 11.9 | val_acc: 0.427 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.400% | train_error: 11.0 | train_acc: 0.469 | val_error: 11.9 | val_acc: 0.427 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.500% | train_error: 11.0 | train_acc: 0.469 | val_error: 11.9 | val_acc: 0.427 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.600% | train_error: 10.8 | train_acc: 0.479 | val_error: 11.9 | val_acc: 0.427 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.700% | train_error: 10.7 | train_acc: 0.484 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.800% | train_error: 10.7 | train_acc: 0.484 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.900% | train_error: 10.7 | train_acc: 0.484 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.00% | train_error: 10.7 | train_acc: 0.484 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.10% | train_error: 10.7 | train_acc: 0.486 | val_error: 11.7 | val_acc: 0.434 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.20% | train_error: 10.7 | train_acc: 0.486 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.30% | train_error: 10.7 | train_acc: 0.486 | val_error: 11.6 | val_acc: 0.441 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.40% | train_error: 10.7 | train_acc: 0.486 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.50% | train_error: 10.4 | train_acc: 0.500 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.60% | train_error: 10.4 | train_acc: 0.500 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.70% | train_error: 10.4 | train_acc: 0.500 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.80% | train_error: 10.4 | train_acc: 0.500 | val_error: 11.4 | val_acc: 0.448 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.90% | train_error: 10.2 | train_acc: 0.507 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.00% | train_error: 9.83 | train_acc: 0.526 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.10% | train_error: 9.83 | train_acc: 0.526 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.20% | train_error: 9.83 | train_acc: 0.526 | val_error: 11.3 | val_acc: 0.455 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.30% | train_error: 9.83 | train_acc: 0.526 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.40% | train_error: 9.83 | train_acc: 0.526 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.50% | train_error: 9.83 | train_acc: 0.526 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.60% | train_error: 9.83 | train_acc: 0.526 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.70% | train_error: 9.73 | train_acc: 0.531 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.80% | train_error: 9.63 | train_acc: 0.535 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.90% | train_error: 9.63 | train_acc: 0.535 | val_error: 11.2 | val_acc: 0.462 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.00% | train_error: 9.53 | train_acc: 0.540 | val_error: 10.9 | val_acc: 0.476 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.10% | train_error: 9.53 | train_acc: 0.540 | val_error: 10.9 | val_acc: 0.476 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.20% | train_error: 9.49 | train_acc: 0.542 | val_error: 10.9 | val_acc: 0.476 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.30% | train_error: 9.49 | train_acc: 0.542 | val_error: 10.9 | val_acc: 0.476 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.40% | train_error: 9.44 | train_acc: 0.545 | val_error: 10.9 | val_acc: 0.476 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.50% | train_error: 9.44 | train_acc: 0.545 | val_error: 10.9 | val_acc: 0.476 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.60% | train_error: 9.39 | train_acc: 0.547 | val_error: 10.9 | val_acc: 0.476 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.70% | train_error: 9.39 | train_acc: 0.547 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.80% | train_error: 9.39 | train_acc: 0.547 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.90% | train_error: 9.34 | train_acc: 0.549 | val_error: 10.7 | val_acc: 0.483 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.00% | train_error: 9.10 | train_acc: 0.561 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.10% | train_error: 9.05 | train_acc: 0.563 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.20% | train_error: 9.05 | train_acc: 0.563 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.30% | train_error: 8.80 | train_acc: 0.575 | val_error: 10.6 | val_acc: 0.490 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.40% | train_error: 8.76 | train_acc: 0.577 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.50% | train_error: 8.56 | train_acc: 0.587 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.60% | train_error: 8.56 | train_acc: 0.587 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.70% | train_error: 8.42 | train_acc: 0.594 | val_error: 10.4 | val_acc: 0.497 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.80% | train_error: 8.42 | train_acc: 0.594 | val_error: 10.3 | val_acc: 0.503 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.90% | train_error: 8.42 | train_acc: 0.594 | val_error: 10.1 | val_acc: 0.510 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.00% | train_error: 8.42 | train_acc: 0.594 | val_error: 10.1 | val_acc: 0.510 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.10% | train_error: 8.32 | train_acc: 0.599 | val_error: 10.1 | val_acc: 0.510 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.20% | train_error: 8.32 | train_acc: 0.599 | val_error: 10.1 | val_acc: 0.510 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.30% | train_error: 8.22 | train_acc: 0.603 | val_error: 10.1 | val_acc: 0.510 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.40% | train_error: 8.22 | train_acc: 0.603 | val_error: 10.1 | val_acc: 0.510 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.50% | train_error: 8.22 | train_acc: 0.603 | val_error: 10.1 | val_acc: 0.510 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.60% | train_error: 8.22 | train_acc: 0.603 | val_error: 10.1 | val_acc: 0.510 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.70% | train_error: 8.17 | train_acc: 0.606 | val_error: 10.1 | val_acc: 0.510 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.80% | train_error: 8.17 | train_acc: 0.606 | val_error: 10.1 | val_acc: 0.510 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.90% | train_error: 8.17 | train_acc: 0.606 | val_error: 10.1 | val_acc: 0.510 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.00% | train_error: 8.08 | train_acc: 0.610 | val_error: 9.85 | val_acc: 0.524 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.10% | train_error: 7.98 | train_acc: 0.615 | val_error: 9.71 | val_acc: 0.531 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.20% | train_error: 7.93 | train_acc: 0.617 | val_error: 9.71 | val_acc: 0.531 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.30% | train_error: 7.93 | train_acc: 0.617 | val_error: 9.71 | val_acc: 0.531 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.40% | train_error: 7.93 | train_acc: 0.617 | val_error: 9.71 | val_acc: 0.531 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.50% | train_error: 7.93 | train_acc: 0.617 | val_error: 9.71 | val_acc: 0.531 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.60% | train_error: 7.93 | train_acc: 0.617 | val_error: 9.71 | val_acc: 0.531 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.70% | train_error: 7.93 | train_acc: 0.617 | val_error: 9.71 | val_acc: 0.531 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.80% | train_error: 7.93 | train_acc: 0.617 | val_error: 9.56 | val_acc: 0.538 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.90% | train_error: 7.93 | train_acc: 0.617 | val_error: 9.27 | val_acc: 0.552 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.00% | train_error: 7.93 | train_acc: 0.617 | val_error: 9.27 | val_acc: 0.552 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.10% | train_error: 7.93 | train_acc: 0.617 | val_error: 9.27 | val_acc: 0.552 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.20% | train_error: 7.88 | train_acc: 0.620 | val_error: 9.27 | val_acc: 0.552 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.30% | train_error: 7.69 | train_acc: 0.629 | val_error: 9.27 | val_acc: 0.552 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.40% | train_error: 7.69 | train_acc: 0.629 | val_error: 9.13 | val_acc: 0.559 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.50% | train_error: 7.69 | train_acc: 0.629 | val_error: 9.13 | val_acc: 0.559 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.60% | train_error: 7.69 | train_acc: 0.629 | val_error: 9.13 | val_acc: 0.559 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.70% | train_error: 7.69 | train_acc: 0.629 | val_error: 8.98 | val_acc: 0.566 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.80% | train_error: 7.59 | train_acc: 0.634 | val_error: 8.84 | val_acc: 0.573 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.90% | train_error: 7.49 | train_acc: 0.638 | val_error: 8.84 | val_acc: 0.573 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.00% | train_error: 7.39 | train_acc: 0.643 | val_error: 8.70 | val_acc: 0.580 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.10% | train_error: 7.39 | train_acc: 0.643 | val_error: 8.55 | val_acc: 0.587 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.20% | train_error: 7.30 | train_acc: 0.648 | val_error: 8.41 | val_acc: 0.594 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.30% | train_error: 7.30 | train_acc: 0.648 | val_error: 8.26 | val_acc: 0.601 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.40% | train_error: 7.15 | train_acc: 0.655 | val_error: 8.26 | val_acc: 0.601 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.50% | train_error: 7.05 | train_acc: 0.660 | val_error: 8.12 | val_acc: 0.608 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.60% | train_error: 7.05 | train_acc: 0.660 | val_error: 7.97 | val_acc: 0.615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.70% | train_error: 6.91 | train_acc: 0.667 | val_error: 7.97 | val_acc: 0.615 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.80% | train_error: 6.86 | train_acc: 0.669 | val_error: 7.83 | val_acc: 0.622 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.90% | train_error: 6.86 | train_acc: 0.669 | val_error: 7.83 | val_acc: 0.622 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.00% | train_error: 6.86 | train_acc: 0.669 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.10% | train_error: 6.76 | train_acc: 0.674 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.20% | train_error: 6.76 | train_acc: 0.674 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.30% | train_error: 6.62 | train_acc: 0.681 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.40% | train_error: 6.57 | train_acc: 0.683 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.50% | train_error: 6.47 | train_acc: 0.688 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.60% | train_error: 6.47 | train_acc: 0.688 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.70% | train_error: 6.37 | train_acc: 0.692 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.80% | train_error: 6.32 | train_acc: 0.695 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.90% | train_error: 6.28 | train_acc: 0.697 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.00% | train_error: 6.28 | train_acc: 0.697 | val_error: 7.54 | val_acc: 0.636 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.10% | train_error: 6.28 | train_acc: 0.697 | val_error: 7.39 | val_acc: 0.643 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.20% | train_error: 6.28 | train_acc: 0.697 | val_error: 7.39 | val_acc: 0.643 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.30% | train_error: 6.28 | train_acc: 0.697 | val_error: 7.10 | val_acc: 0.657 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.40% | train_error: 6.18 | train_acc: 0.702 | val_error: 7.10 | val_acc: 0.657 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.50% | train_error: 6.18 | train_acc: 0.702 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.60% | train_error: 6.13 | train_acc: 0.704 | val_error: 6.81 | val_acc: 0.671 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.70% | train_error: 6.13 | train_acc: 0.704 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.80% | train_error: 6.13 | train_acc: 0.704 | val_error: 6.52 | val_acc: 0.685 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.90% | train_error: 6.13 | train_acc: 0.704 | val_error: 6.52 | val_acc: 0.685 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.00% | train_error: 6.13 | train_acc: 0.704 | val_error: 6.52 | val_acc: 0.685 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.10% | train_error: 6.08 | train_acc: 0.707 | val_error: 6.38 | val_acc: 0.692 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.20% | train_error: 6.03 | train_acc: 0.709 | val_error: 6.52 | val_acc: 0.685 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.30% | train_error: 5.64 | train_acc: 0.728 | val_error: 6.52 | val_acc: 0.685 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.40% | train_error: 5.69 | train_acc: 0.725 | val_error: 6.52 | val_acc: 0.685 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.50% | train_error: 5.69 | train_acc: 0.725 | val_error: 6.52 | val_acc: 0.685 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.60% | train_error: 5.59 | train_acc: 0.730 | val_error: 6.52 | val_acc: 0.685 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.70% | train_error: 5.59 | train_acc: 0.730 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.80% | train_error: 5.55 | train_acc: 0.732 | val_error: 6.67 | val_acc: 0.678 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.90% | train_error: 5.50 | train_acc: 0.735 | val_error: 6.52 | val_acc: 0.685 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.00% | train_error: 5.35 | train_acc: 0.742 | val_error: 6.38 | val_acc: 0.692 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.10% | train_error: 5.35 | train_acc: 0.742 | val_error: 6.23 | val_acc: 0.699 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.20% | train_error: 5.30 | train_acc: 0.744 | val_error: 6.23 | val_acc: 0.699 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.30% | train_error: 5.21 | train_acc: 0.749 | val_error: 6.23 | val_acc: 0.699 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.40% | train_error: 5.06 | train_acc: 0.756 | val_error: 6.23 | val_acc: 0.699 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.50% | train_error: 5.06 | train_acc: 0.756 | val_error: 6.09 | val_acc: 0.706 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.60% | train_error: 5.06 | train_acc: 0.756 | val_error: 6.09 | val_acc: 0.706 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.70% | train_error: 5.01 | train_acc: 0.758 | val_error: 6.09 | val_acc: 0.706 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.80% | train_error: 5.01 | train_acc: 0.758 | val_error: 6.09 | val_acc: 0.706 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.90% | train_error: 4.96 | train_acc: 0.761 | val_error: 6.09 | val_acc: 0.706 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.00% | train_error: 4.96 | train_acc: 0.761 | val_error: 5.65 | val_acc: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.10% | train_error: 4.72 | train_acc: 0.772 | val_error: 5.65 | val_acc: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.20% | train_error: 4.62 | train_acc: 0.777 | val_error: 5.65 | val_acc: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.30% | train_error: 4.52 | train_acc: 0.782 | val_error: 5.65 | val_acc: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.40% | train_error: 4.62 | train_acc: 0.777 | val_error: 5.65 | val_acc: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.50% | train_error: 4.52 | train_acc: 0.782 | val_error: 5.51 | val_acc: 0.734 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.60% | train_error: 4.57 | train_acc: 0.779 | val_error: 5.65 | val_acc: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.70% | train_error: 4.52 | train_acc: 0.782 | val_error: 5.65 | val_acc: 0.727 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.80% | train_error: 4.33 | train_acc: 0.791 | val_error: 5.51 | val_acc: 0.734 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.90% | train_error: 4.33 | train_acc: 0.791 | val_error: 5.36 | val_acc: 0.741 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.00% | train_error: 4.33 | train_acc: 0.791 | val_error: 5.36 | val_acc: 0.741 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.10% | train_error: 4.33 | train_acc: 0.791 | val_error: 5.36 | val_acc: 0.741 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.20% | train_error: 4.33 | train_acc: 0.791 | val_error: 5.07 | val_acc: 0.755 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.30% | train_error: 4.33 | train_acc: 0.791 | val_error: 5.07 | val_acc: 0.755 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.40% | train_error: 4.28 | train_acc: 0.793 | val_error: 5.07 | val_acc: 0.755 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.50% | train_error: 4.28 | train_acc: 0.793 | val_error: 5.07 | val_acc: 0.755 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.60% | train_error: 4.13 | train_acc: 0.800 | val_error: 5.07 | val_acc: 0.755 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.70% | train_error: 4.04 | train_acc: 0.805 | val_error: 4.93 | val_acc: 0.762 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.80% | train_error: 4.04 | train_acc: 0.805 | val_error: 4.78 | val_acc: 0.769 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.90% | train_error: 4.04 | train_acc: 0.805 | val_error: 4.78 | val_acc: 0.769 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.00% | train_error: 3.89 | train_acc: 0.812 | val_error: 4.64 | val_acc: 0.776 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.10% | train_error: 3.84 | train_acc: 0.815 | val_error: 4.64 | val_acc: 0.776 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.20% | train_error: 3.79 | train_acc: 0.817 | val_error: 4.64 | val_acc: 0.776 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.30% | train_error: 3.70 | train_acc: 0.822 | val_error: 4.64 | val_acc: 0.776 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.40% | train_error: 3.70 | train_acc: 0.822 | val_error: 4.49 | val_acc: 0.783 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.50% | train_error: 3.65 | train_acc: 0.824 | val_error: 4.35 | val_acc: 0.790 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.60% | train_error: 3.55 | train_acc: 0.829 | val_error: 4.35 | val_acc: 0.790 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.70% | train_error: 3.55 | train_acc: 0.829 | val_error: 4.35 | val_acc: 0.790 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.80% | train_error: 3.50 | train_acc: 0.831 | val_error: 4.64 | val_acc: 0.776 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.90% | train_error: 3.45 | train_acc: 0.833 | val_error: 4.64 | val_acc: 0.776 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.00% | train_error: 3.21 | train_acc: 0.845 | val_error: 4.35 | val_acc: 0.790 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.10% | train_error: 3.21 | train_acc: 0.845 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.20% | train_error: 3.11 | train_acc: 0.850 | val_error: 4.20 | val_acc: 0.797 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.30% | train_error: 3.11 | train_acc: 0.850 | val_error: 4.35 | val_acc: 0.790 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.40% | train_error: 3.11 | train_acc: 0.850 | val_error: 4.06 | val_acc: 0.804 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.50% | train_error: 3.11 | train_acc: 0.850 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.60% | train_error: 3.11 | train_acc: 0.850 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.70% | train_error: 3.11 | train_acc: 0.850 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.80% | train_error: 3.11 | train_acc: 0.850 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.90% | train_error: 3.11 | train_acc: 0.850 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.00% | train_error: 3.21 | train_acc: 0.845 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.10% | train_error: 3.21 | train_acc: 0.845 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.20% | train_error: 3.21 | train_acc: 0.845 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.30% | train_error: 3.21 | train_acc: 0.845 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.40% | train_error: 3.21 | train_acc: 0.845 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.50% | train_error: 3.02 | train_acc: 0.854 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.60% | train_error: 2.77 | train_acc: 0.866 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.70% | train_error: 2.77 | train_acc: 0.866 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.80% | train_error: 2.72 | train_acc: 0.869 | val_error: 3.91 | val_acc: 0.811 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.90% | train_error: 2.68 | train_acc: 0.871 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.00% | train_error: 2.53 | train_acc: 0.878 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.10% | train_error: 2.48 | train_acc: 0.880 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.20% | train_error: 2.48 | train_acc: 0.880 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.30% | train_error: 2.38 | train_acc: 0.885 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.40% | train_error: 2.38 | train_acc: 0.885 | val_error: 3.77 | val_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.50% | train_error: 2.38 | train_acc: 0.885 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.60% | train_error: 2.29 | train_acc: 0.890 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.70% | train_error: 2.24 | train_acc: 0.892 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.80% | train_error: 2.24 | train_acc: 0.892 | val_error: 3.62 | val_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.90% | train_error: 2.19 | train_acc: 0.894 | val_error: 3.48 | val_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.00% | train_error: 2.19 | train_acc: 0.894 | val_error: 3.33 | val_acc: 0.839 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.10% | train_error: 2.19 | train_acc: 0.894 | val_error: 3.19 | val_acc: 0.846 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.20% | train_error: 2.19 | train_acc: 0.894 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.30% | train_error: 2.19 | train_acc: 0.894 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.40% | train_error: 2.14 | train_acc: 0.897 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.50% | train_error: 2.09 | train_acc: 0.899 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.60% | train_error: 2.04 | train_acc: 0.901 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.70% | train_error: 2.09 | train_acc: 0.899 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.80% | train_error: 2.09 | train_acc: 0.899 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.90% | train_error: 2.09 | train_acc: 0.899 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.00% | train_error: 2.09 | train_acc: 0.899 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.10% | train_error: 2.09 | train_acc: 0.899 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.20% | train_error: 2.09 | train_acc: 0.899 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.30% | train_error: 2.04 | train_acc: 0.901 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.40% | train_error: 2.04 | train_acc: 0.901 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.50% | train_error: 2.04 | train_acc: 0.901 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.60% | train_error: 2.04 | train_acc: 0.901 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.70% | train_error: 2.04 | train_acc: 0.901 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.80% | train_error: 1.99 | train_acc: 0.904 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.90% | train_error: 1.95 | train_acc: 0.906 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.00% | train_error: 1.90 | train_acc: 0.908 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.10% | train_error: 1.90 | train_acc: 0.908 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.20% | train_error: 1.90 | train_acc: 0.908 | val_error: 3.19 | val_acc: 0.846 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.30% | train_error: 1.90 | train_acc: 0.908 | val_error: 3.19 | val_acc: 0.846 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.40% | train_error: 1.90 | train_acc: 0.908 | val_error: 3.19 | val_acc: 0.846 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.50% | train_error: 1.90 | train_acc: 0.908 | val_error: 3.19 | val_acc: 0.846 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.60% | train_error: 1.90 | train_acc: 0.908 | val_error: 3.19 | val_acc: 0.846 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.70% | train_error: 1.90 | train_acc: 0.908 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.80% | train_error: 1.90 | train_acc: 0.908 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.90% | train_error: 1.90 | train_acc: 0.908 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.00% | train_error: 1.75 | train_acc: 0.915 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.10% | train_error: 1.75 | train_acc: 0.915 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.20% | train_error: 1.61 | train_acc: 0.923 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.30% | train_error: 1.61 | train_acc: 0.923 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.40% | train_error: 1.56 | train_acc: 0.925 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.50% | train_error: 1.56 | train_acc: 0.925 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.60% | train_error: 1.56 | train_acc: 0.925 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.70% | train_error: 1.51 | train_acc: 0.927 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.80% | train_error: 1.51 | train_acc: 0.927 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.90% | train_error: 1.51 | train_acc: 0.927 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.00% | train_error: 1.51 | train_acc: 0.927 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.10% | train_error: 1.41 | train_acc: 0.932 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.20% | train_error: 1.41 | train_acc: 0.932 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.30% | train_error: 1.41 | train_acc: 0.932 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.40% | train_error: 1.41 | train_acc: 0.932 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.50% | train_error: 1.41 | train_acc: 0.932 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.60% | train_error: 1.41 | train_acc: 0.932 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.70% | train_error: 1.41 | train_acc: 0.932 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.80% | train_error: 1.31 | train_acc: 0.937 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.90% | train_error: 1.26 | train_acc: 0.939 | val_error: 3.04 | val_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.00% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.10% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.20% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.30% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.90 | val_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.40% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.50% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.60% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.70% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.80% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.90% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.00% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.61 | val_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.10% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.61 | val_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.20% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.61 | val_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.30% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.61 | val_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.40% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.61 | val_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.50% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.60% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.70% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.80% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.90% | train_error: 1.22 | train_acc: 0.941 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.00% | train_error: 1.02 | train_acc: 0.951 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.10% | train_error: 1.02 | train_acc: 0.951 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.20% | train_error: 1.02 | train_acc: 0.951 | val_error: 2.75 | val_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.30% | train_error: 1.02 | train_acc: 0.951 | val_error: 2.61 | val_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.40% | train_error: 1.02 | train_acc: 0.951 | val_error: 2.61 | val_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.50% | train_error: 1.02 | train_acc: 0.951 | val_error: 2.61 | val_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.60% | train_error: 1.02 | train_acc: 0.951 | val_error: 2.61 | val_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.70% | train_error: 1.02 | train_acc: 0.951 | val_error: 2.61 | val_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.80% | train_error: 1.02 | train_acc: 0.951 | val_error: 2.61 | val_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.90% | train_error: 0.876 | train_acc: 0.958 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.00% | train_error: 0.876 | train_acc: 0.958 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.10% | train_error: 0.778 | train_acc: 0.962 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.20% | train_error: 0.778 | train_acc: 0.962 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.30% | train_error: 0.778 | train_acc: 0.962 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.40% | train_error: 0.730 | train_acc: 0.965 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.50% | train_error: 0.730 | train_acc: 0.965 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.60% | train_error: 0.730 | train_acc: 0.965 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.70% | train_error: 0.730 | train_acc: 0.965 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.80% | train_error: 0.730 | train_acc: 0.965 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.90% | train_error: 0.730 | train_acc: 0.965 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.00% | train_error: 0.681 | train_acc: 0.967 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.10% | train_error: 0.681 | train_acc: 0.967 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.20% | train_error: 0.681 | train_acc: 0.967 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.30% | train_error: 0.632 | train_acc: 0.969 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.40% | train_error: 0.632 | train_acc: 0.969 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.50% | train_error: 0.632 | train_acc: 0.969 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.60% | train_error: 0.632 | train_acc: 0.969 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.70% | train_error: 0.632 | train_acc: 0.969 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.80% | train_error: 0.632 | train_acc: 0.969 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.90% | train_error: 0.632 | train_acc: 0.969 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.00% | train_error: 0.535 | train_acc: 0.974 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.10% | train_error: 0.535 | train_acc: 0.974 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.20% | train_error: 0.486 | train_acc: 0.977 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.30% | train_error: 0.341 | train_acc: 0.984 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.40% | train_error: 0.486 | train_acc: 0.977 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.50% | train_error: 0.341 | train_acc: 0.984 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.60% | train_error: 0.486 | train_acc: 0.977 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.70% | train_error: 0.341 | train_acc: 0.984 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.80% | train_error: 0.486 | train_acc: 0.977 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.90% | train_error: 0.341 | train_acc: 0.984 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.00% | train_error: 0.486 | train_acc: 0.977 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.10% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.20% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.30% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.40% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.50% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.60% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.70% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.80% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.90% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.00% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.10% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.20% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.30% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.40% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.50% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.60% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.70% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.80% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.90% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.00% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.10% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.20% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.30% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.40% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.50% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.60% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.70% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.80% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.90% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.00% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.10% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.20% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.30% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.40% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.50% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.60% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.70% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.80% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.90% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.00% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.10% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.20% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.30% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.40% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.50% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.60% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.70% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.80% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.90% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.00% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.10% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.20% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.46 | val_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.30% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.40% | train_error: 0.292 | train_acc: 0.986 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.50% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.60% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.70% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.80% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.90% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.00% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.32 | val_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.10% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.20% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.30% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.40% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.50% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.60% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.70% | train_error: 0.243 | train_acc: 0.988 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.80% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.90% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.00% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.10% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.20% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.30% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.40% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.50% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.60% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.70% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.80% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.90% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.00% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.10% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.20% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.30% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.40% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.50% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.60% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.70% | train_error: 0.195 | train_acc: 0.991 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.80% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.90% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.00% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.10% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.20% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.30% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.40% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.50% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.60% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.70% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.80% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.00% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.20% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.40% | train_error: 0.146 | train_acc: 0.993 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.17 | val_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 2.03 | val_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.00% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.20% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.40% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.60% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.80% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.00% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.10% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.20% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.30% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.40% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.50% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.60% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.70% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.80% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.90% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.00% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.10% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.20% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.30% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.40% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.50% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.60% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.70% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.80% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.90% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.00% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.10% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.20% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.30% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.40% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.50% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.60% | train_error: 0.146 | train_acc: 0.993 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.70% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.90% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.10% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.30% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.50% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.70% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.88 | val_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.90% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.10% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.30% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.50% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.70% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.90% | train_error: 0.0486 | train_acc: 0.998 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.59 | val_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.00% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.10% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.20% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.30% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.40% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.50% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.60% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.70% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.80% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.90% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================================>] 100.0% | train_error: 0.0973 | train_acc: 0.995 | val_error: 1.74 | val_acc: 0.916 " ] } ], "source": [ "neural_network.reset_weights() # reset weights such that previous runs or reruns don't affect the weights\n", "\n", "scheduler = Adam(eta=1e-4, rho=0.9, rho2=0.999)\n", "scores = neural_network.fit(X_train, t_train, scheduler, epochs=1000, X_val=X_val, t_val=t_val)" ] }, { "cell_type": "markdown", "id": "dc8a90af", "metadata": {}, "source": [ "### Multiclass classification\n", "\n", "Finally, we will demonstrate the use case of multiclass classification\n", "using our FFNN with the famous MNIST dataset, which contain images of\n", "digits between the range of 0 to 9." ] }, { "cell_type": "code", "execution_count": 20, "id": "9305c08a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Adam: Eta=0.0001, Lambda=0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.000% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.1000% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.2000% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.3000% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.4000% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.5000% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.6000% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.7000% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.8000% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.9000% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.000% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.100% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.200% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.300% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.400% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.500% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.600% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.700% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.800% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.900% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.000% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.100% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.200% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.300% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.400% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.500% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.600% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.700% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.800% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.900% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.000% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.100% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.200% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.300% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.400% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.500% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.600% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.700% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.800% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.900% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.000% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.100% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.200% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.300% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.400% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.500% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.600% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.700% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.800% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.900% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.000% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.100% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.200% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.300% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.400% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.500% | train_error: 1.84 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.600% | train_error: 1.84 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.700% | train_error: 1.84 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.800% | train_error: 1.84 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.900% | train_error: 1.84 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.000% | train_error: 1.84 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.100% | train_error: 1.84 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.200% | train_error: 1.84 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.300% | train_error: 1.84 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.400% | train_error: 1.84 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.500% | train_error: 1.84 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.600% | train_error: 1.84 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.700% | train_error: 1.84 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.800% | train_error: 1.84 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.900% | train_error: 1.85 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.000% | train_error: 1.85 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.100% | train_error: 1.85 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.200% | train_error: 1.85 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.300% | train_error: 1.85 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.400% | train_error: 1.85 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.500% | train_error: 1.86 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.600% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.700% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.800% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.900% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.000% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.100% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.200% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.300% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.400% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.500% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.600% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.700% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.800% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.900% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.000% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.100% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.200% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.300% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.400% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.500% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.600% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.700% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.800% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.900% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.00% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.10% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.20% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.30% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.40% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.50% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.60% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.70% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.80% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.90% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.00% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.10% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.20% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.30% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.40% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.50% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.60% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.70% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.80% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.90% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.00% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.10% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.20% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.30% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.40% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.50% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.60% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.70% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.80% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.90% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.00% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.10% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.20% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.30% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.40% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.50% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.60% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.70% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.80% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.90% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.00% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.10% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.20% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.30% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.40% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.50% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.60% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.70% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.80% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.90% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.00% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.10% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.20% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.30% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.40% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.50% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.60% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.70% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.80% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.90% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.00% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.10% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.20% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.30% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.40% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.50% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.60% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.70% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.80% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.90% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.00% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.10% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.20% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.30% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.40% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.50% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.60% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.70% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.80% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.90% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.00% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.10% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.20% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.30% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.40% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.50% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.60% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.70% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.80% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.90% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.00% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.10% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.20% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.30% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.40% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.50% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.60% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.70% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.80% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.90% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.00% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.10% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.20% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.30% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.40% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.50% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.60% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.70% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.80% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.90% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.00% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.10% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.20% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.30% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.40% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.50% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.60% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.70% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.80% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.90% | train_error: 1.88 | train_acc: 0.818 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.00% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.10% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.20% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.30% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.40% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.50% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.60% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.70% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.80% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.90% | train_error: 1.88 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.00% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.10% | train_error: 1.87 | train_acc: 0.819 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.20% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.30% | train_error: 1.87 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.40% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.50% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.60% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.70% | train_error: 1.86 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.80% | train_error: 1.86 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.90% | train_error: 1.86 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.00% | train_error: 1.86 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.10% | train_error: 1.86 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.20% | train_error: 1.86 | train_acc: 0.820 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.30% | train_error: 1.86 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.40% | train_error: 1.86 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.50% | train_error: 1.85 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.60% | train_error: 1.85 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.70% | train_error: 1.85 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.80% | train_error: 1.85 | train_acc: 0.821 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.90% | train_error: 1.85 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.00% | train_error: 1.85 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.10% | train_error: 1.84 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.20% | train_error: 1.84 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.30% | train_error: 1.84 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.40% | train_error: 1.84 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.50% | train_error: 1.84 | train_acc: 0.822 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.60% | train_error: 1.84 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.70% | train_error: 1.84 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.80% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.90% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.00% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.10% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.20% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.30% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.40% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.50% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.60% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.70% | train_error: 1.83 | train_acc: 0.823 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.80% | train_error: 1.83 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.90% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.00% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.10% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.20% | train_error: 1.82 | train_acc: 0.824 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.30% | train_error: 1.82 | train_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.40% | train_error: 1.82 | train_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.50% | train_error: 1.82 | train_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.60% | train_error: 1.82 | train_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.70% | train_error: 1.81 | train_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.80% | train_error: 1.81 | train_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.90% | train_error: 1.81 | train_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.00% | train_error: 1.81 | train_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.10% | train_error: 1.81 | train_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.20% | train_error: 1.81 | train_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.30% | train_error: 1.81 | train_acc: 0.825 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.40% | train_error: 1.80 | train_acc: 0.826 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.50% | train_error: 1.80 | train_acc: 0.826 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.60% | train_error: 1.80 | train_acc: 0.826 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.70% | train_error: 1.80 | train_acc: 0.826 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.80% | train_error: 1.80 | train_acc: 0.826 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.90% | train_error: 1.80 | train_acc: 0.826 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.00% | train_error: 1.80 | train_acc: 0.826 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.10% | train_error: 1.80 | train_acc: 0.826 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.20% | train_error: 1.80 | train_acc: 0.827 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.30% | train_error: 1.80 | train_acc: 0.827 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.40% | train_error: 1.80 | train_acc: 0.826 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.50% | train_error: 1.80 | train_acc: 0.827 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.60% | train_error: 1.80 | train_acc: 0.827 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.70% | train_error: 1.80 | train_acc: 0.826 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.80% | train_error: 1.79 | train_acc: 0.827 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.90% | train_error: 1.79 | train_acc: 0.827 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.00% | train_error: 1.79 | train_acc: 0.827 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.10% | train_error: 1.79 | train_acc: 0.828 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.20% | train_error: 1.79 | train_acc: 0.827 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.30% | train_error: 1.79 | train_acc: 0.827 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.40% | train_error: 1.79 | train_acc: 0.827 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.50% | train_error: 1.79 | train_acc: 0.828 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.60% | train_error: 1.78 | train_acc: 0.828 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.70% | train_error: 1.78 | train_acc: 0.828 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.80% | train_error: 1.78 | train_acc: 0.828 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.90% | train_error: 1.78 | train_acc: 0.828 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.00% | train_error: 1.78 | train_acc: 0.828 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.10% | train_error: 1.78 | train_acc: 0.828 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.20% | train_error: 1.78 | train_acc: 0.828 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.30% | train_error: 1.78 | train_acc: 0.828 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.40% | train_error: 1.78 | train_acc: 0.829 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.50% | train_error: 1.78 | train_acc: 0.829 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.60% | train_error: 1.77 | train_acc: 0.829 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.70% | train_error: 1.78 | train_acc: 0.829 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.80% | train_error: 1.78 | train_acc: 0.829 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.90% | train_error: 1.77 | train_acc: 0.829 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.00% | train_error: 1.77 | train_acc: 0.829 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.10% | train_error: 1.76 | train_acc: 0.830 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.20% | train_error: 1.77 | train_acc: 0.829 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.30% | train_error: 1.76 | train_acc: 0.830 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.40% | train_error: 1.76 | train_acc: 0.830 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.50% | train_error: 1.76 | train_acc: 0.830 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.60% | train_error: 1.76 | train_acc: 0.830 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.70% | train_error: 1.76 | train_acc: 0.830 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.80% | train_error: 1.76 | train_acc: 0.830 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.90% | train_error: 1.76 | train_acc: 0.831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.00% | train_error: 1.75 | train_acc: 0.831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.10% | train_error: 1.75 | train_acc: 0.831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.20% | train_error: 1.75 | train_acc: 0.831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.30% | train_error: 1.75 | train_acc: 0.831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.40% | train_error: 1.75 | train_acc: 0.831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.50% | train_error: 1.75 | train_acc: 0.831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.60% | train_error: 1.75 | train_acc: 0.831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.70% | train_error: 1.75 | train_acc: 0.831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.80% | train_error: 1.75 | train_acc: 0.831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.90% | train_error: 1.75 | train_acc: 0.831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.00% | train_error: 1.75 | train_acc: 0.831 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.10% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.20% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.30% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.40% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.50% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.60% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.70% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.80% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.90% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.00% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.10% | train_error: 1.73 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.20% | train_error: 1.73 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.30% | train_error: 1.72 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.40% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.50% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.60% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.70% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.80% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.90% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.00% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.10% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.20% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.30% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.40% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.50% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.60% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.70% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.80% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.90% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.00% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.10% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.20% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.30% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.40% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.50% | train_error: 1.74 | train_acc: 0.832 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.60% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.70% | train_error: 1.72 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.80% | train_error: 1.73 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.90% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.00% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.10% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.20% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.30% | train_error: 1.72 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.40% | train_error: 1.73 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.50% | train_error: 1.73 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.60% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.70% | train_error: 1.73 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.80% | train_error: 1.72 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.90% | train_error: 1.72 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.00% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.10% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.20% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.30% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.40% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.50% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.60% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.70% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.80% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.90% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.00% | train_error: 1.73 | train_acc: 0.833 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.10% | train_error: 1.72 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.20% | train_error: 1.72 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.30% | train_error: 1.72 | train_acc: 0.834 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.40% | train_error: 1.71 | train_acc: 0.835 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.50% | train_error: 1.71 | train_acc: 0.835 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.60% | train_error: 1.71 | train_acc: 0.835 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.70% | train_error: 1.71 | train_acc: 0.835 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.80% | train_error: 1.71 | train_acc: 0.835 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.90% | train_error: 1.71 | train_acc: 0.835 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.00% | train_error: 1.71 | train_acc: 0.835 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.10% | train_error: 1.71 | train_acc: 0.835 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.20% | train_error: 1.71 | train_acc: 0.835 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.30% | train_error: 1.71 | train_acc: 0.835 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.40% | train_error: 1.71 | train_acc: 0.835 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.50% | train_error: 1.70 | train_acc: 0.836 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.60% | train_error: 1.70 | train_acc: 0.836 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.70% | train_error: 1.70 | train_acc: 0.836 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.80% | train_error: 1.70 | train_acc: 0.836 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.90% | train_error: 1.70 | train_acc: 0.836 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.00% | train_error: 1.70 | train_acc: 0.836 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.10% | train_error: 1.69 | train_acc: 0.837 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.20% | train_error: 1.69 | train_acc: 0.837 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.30% | train_error: 1.69 | train_acc: 0.837 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.40% | train_error: 1.69 | train_acc: 0.837 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.50% | train_error: 1.69 | train_acc: 0.837 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.60% | train_error: 1.69 | train_acc: 0.837 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.70% | train_error: 1.68 | train_acc: 0.838 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.80% | train_error: 1.68 | train_acc: 0.838 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.90% | train_error: 1.68 | train_acc: 0.838 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.00% | train_error: 1.68 | train_acc: 0.838 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.10% | train_error: 1.68 | train_acc: 0.838 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.20% | train_error: 1.67 | train_acc: 0.839 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.30% | train_error: 1.67 | train_acc: 0.839 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.40% | train_error: 1.67 | train_acc: 0.839 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.50% | train_error: 1.67 | train_acc: 0.839 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.60% | train_error: 1.66 | train_acc: 0.840 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.70% | train_error: 1.66 | train_acc: 0.840 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.80% | train_error: 1.65 | train_acc: 0.840 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.90% | train_error: 1.65 | train_acc: 0.841 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.00% | train_error: 1.65 | train_acc: 0.841 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.10% | train_error: 1.64 | train_acc: 0.841 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.20% | train_error: 1.64 | train_acc: 0.842 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.30% | train_error: 1.62 | train_acc: 0.843 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.40% | train_error: 1.62 | train_acc: 0.843 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.50% | train_error: 1.62 | train_acc: 0.843 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.60% | train_error: 1.62 | train_acc: 0.844 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.70% | train_error: 1.61 | train_acc: 0.844 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.80% | train_error: 1.61 | train_acc: 0.845 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.90% | train_error: 1.60 | train_acc: 0.846 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.00% | train_error: 1.59 | train_acc: 0.846 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.10% | train_error: 1.59 | train_acc: 0.846 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.20% | train_error: 1.59 | train_acc: 0.847 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.30% | train_error: 1.58 | train_acc: 0.847 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.40% | train_error: 1.58 | train_acc: 0.847 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.50% | train_error: 1.58 | train_acc: 0.848 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.60% | train_error: 1.57 | train_acc: 0.848 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.70% | train_error: 1.57 | train_acc: 0.849 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.80% | train_error: 1.56 | train_acc: 0.849 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.90% | train_error: 1.56 | train_acc: 0.850 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.00% | train_error: 1.55 | train_acc: 0.850 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.10% | train_error: 1.55 | train_acc: 0.851 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.20% | train_error: 1.55 | train_acc: 0.851 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.30% | train_error: 1.54 | train_acc: 0.852 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.40% | train_error: 1.53 | train_acc: 0.852 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.50% | train_error: 1.53 | train_acc: 0.852 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.60% | train_error: 1.53 | train_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.70% | train_error: 1.52 | train_acc: 0.853 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.80% | train_error: 1.52 | train_acc: 0.854 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.90% | train_error: 1.52 | train_acc: 0.854 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.00% | train_error: 1.51 | train_acc: 0.854 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.10% | train_error: 1.51 | train_acc: 0.854 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.20% | train_error: 1.50 | train_acc: 0.855 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.30% | train_error: 1.50 | train_acc: 0.855 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.40% | train_error: 1.49 | train_acc: 0.856 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.50% | train_error: 1.47 | train_acc: 0.858 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.60% | train_error: 1.47 | train_acc: 0.858 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.70% | train_error: 1.47 | train_acc: 0.858 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.80% | train_error: 1.46 | train_acc: 0.859 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.90% | train_error: 1.46 | train_acc: 0.859 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.00% | train_error: 1.46 | train_acc: 0.859 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.10% | train_error: 1.46 | train_acc: 0.859 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.20% | train_error: 1.46 | train_acc: 0.859 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.30% | train_error: 1.46 | train_acc: 0.859 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.40% | train_error: 1.45 | train_acc: 0.860 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.50% | train_error: 1.44 | train_acc: 0.861 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.60% | train_error: 1.44 | train_acc: 0.861 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.70% | train_error: 1.44 | train_acc: 0.861 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.80% | train_error: 1.44 | train_acc: 0.861 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.90% | train_error: 1.43 | train_acc: 0.862 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.00% | train_error: 1.42 | train_acc: 0.863 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.10% | train_error: 1.41 | train_acc: 0.864 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.20% | train_error: 1.40 | train_acc: 0.865 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.30% | train_error: 1.39 | train_acc: 0.866 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.40% | train_error: 1.39 | train_acc: 0.866 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.50% | train_error: 1.39 | train_acc: 0.866 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.60% | train_error: 1.39 | train_acc: 0.866 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.70% | train_error: 1.38 | train_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.80% | train_error: 1.38 | train_acc: 0.867 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.90% | train_error: 1.37 | train_acc: 0.868 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.00% | train_error: 1.36 | train_acc: 0.869 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.10% | train_error: 1.35 | train_acc: 0.869 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.20% | train_error: 1.35 | train_acc: 0.870 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.30% | train_error: 1.34 | train_acc: 0.870 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.40% | train_error: 1.34 | train_acc: 0.870 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.50% | train_error: 1.34 | train_acc: 0.870 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.60% | train_error: 1.34 | train_acc: 0.871 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.70% | train_error: 1.33 | train_acc: 0.872 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.80% | train_error: 1.32 | train_acc: 0.873 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.90% | train_error: 1.31 | train_acc: 0.873 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.00% | train_error: 1.31 | train_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.10% | train_error: 1.31 | train_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.20% | train_error: 1.31 | train_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.30% | train_error: 1.31 | train_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.40% | train_error: 1.31 | train_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.50% | train_error: 1.31 | train_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.60% | train_error: 1.30 | train_acc: 0.874 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.70% | train_error: 1.30 | train_acc: 0.875 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.80% | train_error: 1.30 | train_acc: 0.875 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.90% | train_error: 1.29 | train_acc: 0.875 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.00% | train_error: 1.29 | train_acc: 0.875 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.10% | train_error: 1.29 | train_acc: 0.875 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.20% | train_error: 1.29 | train_acc: 0.875 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.30% | train_error: 1.29 | train_acc: 0.876 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.40% | train_error: 1.28 | train_acc: 0.876 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.50% | train_error: 1.28 | train_acc: 0.876 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.60% | train_error: 1.28 | train_acc: 0.877 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.70% | train_error: 1.28 | train_acc: 0.877 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.80% | train_error: 1.27 | train_acc: 0.877 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.90% | train_error: 1.27 | train_acc: 0.877 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.00% | train_error: 1.27 | train_acc: 0.877 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.10% | train_error: 1.27 | train_acc: 0.878 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.20% | train_error: 1.26 | train_acc: 0.878 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.30% | train_error: 1.26 | train_acc: 0.878 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.40% | train_error: 1.26 | train_acc: 0.879 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.50% | train_error: 1.25 | train_acc: 0.879 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.60% | train_error: 1.25 | train_acc: 0.880 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.70% | train_error: 1.24 | train_acc: 0.880 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.80% | train_error: 1.24 | train_acc: 0.880 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.90% | train_error: 1.24 | train_acc: 0.880 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.00% | train_error: 1.23 | train_acc: 0.881 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.10% | train_error: 1.22 | train_acc: 0.882 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.20% | train_error: 1.22 | train_acc: 0.882 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.30% | train_error: 1.21 | train_acc: 0.883 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.40% | train_error: 1.21 | train_acc: 0.883 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.50% | train_error: 1.21 | train_acc: 0.883 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.60% | train_error: 1.21 | train_acc: 0.883 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.70% | train_error: 1.21 | train_acc: 0.884 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.80% | train_error: 1.20 | train_acc: 0.884 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.90% | train_error: 1.20 | train_acc: 0.884 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.00% | train_error: 1.20 | train_acc: 0.884 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.10% | train_error: 1.20 | train_acc: 0.884 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.20% | train_error: 1.19 | train_acc: 0.885 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.30% | train_error: 1.19 | train_acc: 0.885 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.40% | train_error: 1.19 | train_acc: 0.885 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.50% | train_error: 1.19 | train_acc: 0.885 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.60% | train_error: 1.19 | train_acc: 0.885 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.70% | train_error: 1.19 | train_acc: 0.885 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.80% | train_error: 1.18 | train_acc: 0.886 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.90% | train_error: 1.19 | train_acc: 0.885 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.00% | train_error: 1.19 | train_acc: 0.885 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.10% | train_error: 1.18 | train_acc: 0.886 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.20% | train_error: 1.18 | train_acc: 0.886 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.30% | train_error: 1.17 | train_acc: 0.887 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.40% | train_error: 1.17 | train_acc: 0.887 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.50% | train_error: 1.17 | train_acc: 0.887 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.60% | train_error: 1.16 | train_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.70% | train_error: 1.16 | train_acc: 0.888 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.80% | train_error: 1.15 | train_acc: 0.889 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.90% | train_error: 1.15 | train_acc: 0.889 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.00% | train_error: 1.14 | train_acc: 0.890 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.10% | train_error: 1.14 | train_acc: 0.890 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.20% | train_error: 1.14 | train_acc: 0.890 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.30% | train_error: 1.14 | train_acc: 0.890 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.40% | train_error: 1.13 | train_acc: 0.891 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.50% | train_error: 1.13 | train_acc: 0.891 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.60% | train_error: 1.13 | train_acc: 0.891 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.70% | train_error: 1.12 | train_acc: 0.891 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.80% | train_error: 1.13 | train_acc: 0.891 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.90% | train_error: 1.12 | train_acc: 0.892 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.00% | train_error: 1.11 | train_acc: 0.893 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.10% | train_error: 1.11 | train_acc: 0.893 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.20% | train_error: 1.09 | train_acc: 0.894 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.30% | train_error: 1.09 | train_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.40% | train_error: 1.09 | train_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.50% | train_error: 1.09 | train_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.60% | train_error: 1.09 | train_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.70% | train_error: 1.09 | train_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.80% | train_error: 1.08 | train_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.90% | train_error: 1.08 | train_acc: 0.895 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.00% | train_error: 1.08 | train_acc: 0.896 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.10% | train_error: 1.08 | train_acc: 0.896 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.20% | train_error: 1.08 | train_acc: 0.896 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.30% | train_error: 1.07 | train_acc: 0.896 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.40% | train_error: 1.07 | train_acc: 0.897 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.50% | train_error: 1.06 | train_acc: 0.898 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.60% | train_error: 1.05 | train_acc: 0.898 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.70% | train_error: 1.05 | train_acc: 0.899 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.80% | train_error: 1.04 | train_acc: 0.899 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.90% | train_error: 1.04 | train_acc: 0.899 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.00% | train_error: 1.04 | train_acc: 0.899 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.10% | train_error: 1.04 | train_acc: 0.900 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.20% | train_error: 1.03 | train_acc: 0.900 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.30% | train_error: 1.03 | train_acc: 0.901 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.40% | train_error: 1.03 | train_acc: 0.901 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.50% | train_error: 1.02 | train_acc: 0.901 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.60% | train_error: 1.02 | train_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.70% | train_error: 1.01 | train_acc: 0.902 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.80% | train_error: 1.01 | train_acc: 0.903 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.90% | train_error: 1.00 | train_acc: 0.903 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.00% | train_error: 1.00 | train_acc: 0.903 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.10% | train_error: 1.00 | train_acc: 0.903 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.20% | train_error: 1.00 | train_acc: 0.903 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.30% | train_error: 0.999 | train_acc: 0.904 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.40% | train_error: 0.998 | train_acc: 0.904 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.50% | train_error: 0.998 | train_acc: 0.904 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.60% | train_error: 0.994 | train_acc: 0.904 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.70% | train_error: 0.994 | train_acc: 0.904 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.80% | train_error: 0.991 | train_acc: 0.904 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.90% | train_error: 0.987 | train_acc: 0.905 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.00% | train_error: 0.986 | train_acc: 0.905 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.10% | train_error: 0.978 | train_acc: 0.906 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.20% | train_error: 0.976 | train_acc: 0.906 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.30% | train_error: 0.976 | train_acc: 0.906 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.40% | train_error: 0.973 | train_acc: 0.906 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.50% | train_error: 0.972 | train_acc: 0.906 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.60% | train_error: 0.968 | train_acc: 0.907 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.70% | train_error: 0.968 | train_acc: 0.907 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.80% | train_error: 0.965 | train_acc: 0.907 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.90% | train_error: 0.966 | train_acc: 0.907 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.00% | train_error: 0.962 | train_acc: 0.907 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.10% | train_error: 0.954 | train_acc: 0.908 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.20% | train_error: 0.951 | train_acc: 0.908 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.30% | train_error: 0.948 | train_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.40% | train_error: 0.946 | train_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.50% | train_error: 0.943 | train_acc: 0.909 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.60% | train_error: 0.935 | train_acc: 0.910 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.70% | train_error: 0.926 | train_acc: 0.911 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.80% | train_error: 0.926 | train_acc: 0.911 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.90% | train_error: 0.926 | train_acc: 0.911 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.00% | train_error: 0.914 | train_acc: 0.912 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.10% | train_error: 0.914 | train_acc: 0.912 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.20% | train_error: 0.906 | train_acc: 0.913 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.30% | train_error: 0.903 | train_acc: 0.913 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.40% | train_error: 0.900 | train_acc: 0.913 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.50% | train_error: 0.895 | train_acc: 0.914 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.60% | train_error: 0.894 | train_acc: 0.914 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.70% | train_error: 0.891 | train_acc: 0.914 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.80% | train_error: 0.893 | train_acc: 0.914 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.90% | train_error: 0.893 | train_acc: 0.914 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.00% | train_error: 0.890 | train_acc: 0.914 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.10% | train_error: 0.889 | train_acc: 0.914 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.20% | train_error: 0.883 | train_acc: 0.915 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.30% | train_error: 0.880 | train_acc: 0.915 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.40% | train_error: 0.878 | train_acc: 0.915 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.50% | train_error: 0.876 | train_acc: 0.915 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.60% | train_error: 0.875 | train_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.70% | train_error: 0.874 | train_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.80% | train_error: 0.875 | train_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.90% | train_error: 0.873 | train_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.00% | train_error: 0.871 | train_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.10% | train_error: 0.868 | train_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.20% | train_error: 0.866 | train_acc: 0.916 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.30% | train_error: 0.864 | train_acc: 0.917 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.40% | train_error: 0.855 | train_acc: 0.918 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.50% | train_error: 0.851 | train_acc: 0.918 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.60% | train_error: 0.850 | train_acc: 0.918 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.70% | train_error: 0.850 | train_acc: 0.918 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.80% | train_error: 0.848 | train_acc: 0.918 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.90% | train_error: 0.844 | train_acc: 0.919 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.00% | train_error: 0.845 | train_acc: 0.918 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.10% | train_error: 0.842 | train_acc: 0.919 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.20% | train_error: 0.841 | train_acc: 0.919 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.30% | train_error: 0.841 | train_acc: 0.919 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.40% | train_error: 0.836 | train_acc: 0.919 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.50% | train_error: 0.821 | train_acc: 0.921 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.60% | train_error: 0.808 | train_acc: 0.922 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.70% | train_error: 0.805 | train_acc: 0.922 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.80% | train_error: 0.800 | train_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.90% | train_error: 0.799 | train_acc: 0.923 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.00% | train_error: 0.792 | train_acc: 0.924 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.10% | train_error: 0.791 | train_acc: 0.924 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.20% | train_error: 0.782 | train_acc: 0.925 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.30% | train_error: 0.774 | train_acc: 0.925 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.40% | train_error: 0.766 | train_acc: 0.926 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.50% | train_error: 0.763 | train_acc: 0.926 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.60% | train_error: 0.757 | train_acc: 0.927 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.70% | train_error: 0.753 | train_acc: 0.927 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.80% | train_error: 0.754 | train_acc: 0.927 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.90% | train_error: 0.747 | train_acc: 0.928 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.00% | train_error: 0.740 | train_acc: 0.929 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.10% | train_error: 0.746 | train_acc: 0.928 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.20% | train_error: 0.737 | train_acc: 0.929 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.30% | train_error: 0.744 | train_acc: 0.928 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.40% | train_error: 0.736 | train_acc: 0.929 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.50% | train_error: 0.745 | train_acc: 0.928 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.60% | train_error: 0.737 | train_acc: 0.929 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.70% | train_error: 0.736 | train_acc: 0.929 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.80% | train_error: 0.724 | train_acc: 0.930 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.90% | train_error: 0.722 | train_acc: 0.930 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.00% | train_error: 0.718 | train_acc: 0.931 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.10% | train_error: 0.718 | train_acc: 0.931 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.20% | train_error: 0.717 | train_acc: 0.931 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.30% | train_error: 0.712 | train_acc: 0.931 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.40% | train_error: 0.713 | train_acc: 0.931 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.50% | train_error: 0.710 | train_acc: 0.931 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.60% | train_error: 0.708 | train_acc: 0.932 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.70% | train_error: 0.705 | train_acc: 0.932 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.80% | train_error: 0.702 | train_acc: 0.932 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.90% | train_error: 0.701 | train_acc: 0.932 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.00% | train_error: 0.695 | train_acc: 0.933 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.10% | train_error: 0.694 | train_acc: 0.933 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.20% | train_error: 0.691 | train_acc: 0.933 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.30% | train_error: 0.687 | train_acc: 0.934 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.40% | train_error: 0.683 | train_acc: 0.934 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.50% | train_error: 0.682 | train_acc: 0.934 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.60% | train_error: 0.677 | train_acc: 0.935 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.70% | train_error: 0.672 | train_acc: 0.935 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.80% | train_error: 0.669 | train_acc: 0.935 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.90% | train_error: 0.669 | train_acc: 0.935 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.00% | train_error: 0.668 | train_acc: 0.936 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.10% | train_error: 0.665 | train_acc: 0.936 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.20% | train_error: 0.658 | train_acc: 0.936 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.30% | train_error: 0.655 | train_acc: 0.937 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.40% | train_error: 0.654 | train_acc: 0.937 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.50% | train_error: 0.657 | train_acc: 0.937 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.60% | train_error: 0.652 | train_acc: 0.937 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.70% | train_error: 0.647 | train_acc: 0.938 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.80% | train_error: 0.645 | train_acc: 0.938 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.90% | train_error: 0.645 | train_acc: 0.938 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.00% | train_error: 0.630 | train_acc: 0.939 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.10% | train_error: 0.637 | train_acc: 0.939 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.20% | train_error: 0.624 | train_acc: 0.940 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.30% | train_error: 0.630 | train_acc: 0.939 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.40% | train_error: 0.618 | train_acc: 0.940 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.50% | train_error: 0.623 | train_acc: 0.940 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.60% | train_error: 0.611 | train_acc: 0.941 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.70% | train_error: 0.612 | train_acc: 0.941 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.80% | train_error: 0.614 | train_acc: 0.941 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.90% | train_error: 0.608 | train_acc: 0.941 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.00% | train_error: 0.605 | train_acc: 0.942 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.10% | train_error: 0.609 | train_acc: 0.941 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.20% | train_error: 0.604 | train_acc: 0.942 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.30% | train_error: 0.601 | train_acc: 0.942 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.40% | train_error: 0.600 | train_acc: 0.942 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.50% | train_error: 0.601 | train_acc: 0.942 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.60% | train_error: 0.599 | train_acc: 0.942 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.70% | train_error: 0.593 | train_acc: 0.943 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.80% | train_error: 0.592 | train_acc: 0.943 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.90% | train_error: 0.593 | train_acc: 0.943 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.00% | train_error: 0.589 | train_acc: 0.943 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.10% | train_error: 0.590 | train_acc: 0.943 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.20% | train_error: 0.585 | train_acc: 0.944 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.30% | train_error: 0.590 | train_acc: 0.943 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.40% | train_error: 0.580 | train_acc: 0.944 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.50% | train_error: 0.579 | train_acc: 0.944 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.60% | train_error: 0.574 | train_acc: 0.945 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.70% | train_error: 0.578 | train_acc: 0.944 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.80% | train_error: 0.560 | train_acc: 0.946 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.90% | train_error: 0.566 | train_acc: 0.945 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.00% | train_error: 0.564 | train_acc: 0.946 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.10% | train_error: 0.563 | train_acc: 0.946 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.20% | train_error: 0.559 | train_acc: 0.946 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.30% | train_error: 0.560 | train_acc: 0.946 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.40% | train_error: 0.549 | train_acc: 0.947 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.50% | train_error: 0.563 | train_acc: 0.946 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.60% | train_error: 0.542 | train_acc: 0.948 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.70% | train_error: 0.558 | train_acc: 0.946 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.80% | train_error: 0.542 | train_acc: 0.948 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.90% | train_error: 0.556 | train_acc: 0.946 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.00% | train_error: 0.536 | train_acc: 0.948 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.10% | train_error: 0.549 | train_acc: 0.947 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.20% | train_error: 0.529 | train_acc: 0.949 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.30% | train_error: 0.536 | train_acc: 0.948 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.40% | train_error: 0.534 | train_acc: 0.949 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.50% | train_error: 0.532 | train_acc: 0.949 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.60% | train_error: 0.528 | train_acc: 0.949 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.70% | train_error: 0.526 | train_acc: 0.949 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.80% | train_error: 0.515 | train_acc: 0.950 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.90% | train_error: 0.517 | train_acc: 0.950 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.00% | train_error: 0.510 | train_acc: 0.951 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.10% | train_error: 0.511 | train_acc: 0.951 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.20% | train_error: 0.510 | train_acc: 0.951 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.30% | train_error: 0.504 | train_acc: 0.951 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.40% | train_error: 0.510 | train_acc: 0.951 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.50% | train_error: 0.507 | train_acc: 0.951 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.60% | train_error: 0.509 | train_acc: 0.951 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.70% | train_error: 0.499 | train_acc: 0.952 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.80% | train_error: 0.506 | train_acc: 0.951 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.90% | train_error: 0.499 | train_acc: 0.952 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.00% | train_error: 0.504 | train_acc: 0.951 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.10% | train_error: 0.503 | train_acc: 0.952 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.20% | train_error: 0.495 | train_acc: 0.952 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.30% | train_error: 0.495 | train_acc: 0.952 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.40% | train_error: 0.488 | train_acc: 0.953 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.50% | train_error: 0.482 | train_acc: 0.953 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.60% | train_error: 0.473 | train_acc: 0.954 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.70% | train_error: 0.476 | train_acc: 0.954 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.80% | train_error: 0.477 | train_acc: 0.954 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.90% | train_error: 0.468 | train_acc: 0.955 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.00% | train_error: 0.472 | train_acc: 0.954 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.10% | train_error: 0.466 | train_acc: 0.955 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.20% | train_error: 0.473 | train_acc: 0.954 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.30% | train_error: 0.464 | train_acc: 0.955 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.40% | train_error: 0.467 | train_acc: 0.955 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.50% | train_error: 0.458 | train_acc: 0.956 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.60% | train_error: 0.461 | train_acc: 0.955 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.70% | train_error: 0.449 | train_acc: 0.957 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.80% | train_error: 0.464 | train_acc: 0.955 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.90% | train_error: 0.446 | train_acc: 0.957 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.00% | train_error: 0.456 | train_acc: 0.956 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.10% | train_error: 0.449 | train_acc: 0.957 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.20% | train_error: 0.454 | train_acc: 0.956 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.30% | train_error: 0.446 | train_acc: 0.957 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.40% | train_error: 0.443 | train_acc: 0.957 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.50% | train_error: 0.443 | train_acc: 0.957 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.60% | train_error: 0.429 | train_acc: 0.959 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.70% | train_error: 0.434 | train_acc: 0.958 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.80% | train_error: 0.427 | train_acc: 0.959 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.90% | train_error: 0.422 | train_acc: 0.959 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.00% | train_error: 0.419 | train_acc: 0.960 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.10% | train_error: 0.424 | train_acc: 0.959 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.20% | train_error: 0.424 | train_acc: 0.959 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.30% | train_error: 0.422 | train_acc: 0.959 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.40% | train_error: 0.417 | train_acc: 0.960 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.50% | train_error: 0.413 | train_acc: 0.960 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.60% | train_error: 0.408 | train_acc: 0.961 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.70% | train_error: 0.401 | train_acc: 0.961 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.80% | train_error: 0.402 | train_acc: 0.961 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.90% | train_error: 0.396 | train_acc: 0.962 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.00% | train_error: 0.402 | train_acc: 0.961 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.10% | train_error: 0.399 | train_acc: 0.962 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.20% | train_error: 0.401 | train_acc: 0.961 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.30% | train_error: 0.389 | train_acc: 0.962 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.40% | train_error: 0.397 | train_acc: 0.962 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.50% | train_error: 0.386 | train_acc: 0.963 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.60% | train_error: 0.389 | train_acc: 0.963 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.70% | train_error: 0.386 | train_acc: 0.963 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.80% | train_error: 0.385 | train_acc: 0.963 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.90% | train_error: 0.385 | train_acc: 0.963 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.00% | train_error: 0.382 | train_acc: 0.963 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.10% | train_error: 0.378 | train_acc: 0.963 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.20% | train_error: 0.374 | train_acc: 0.964 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.30% | train_error: 0.372 | train_acc: 0.964 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.40% | train_error: 0.371 | train_acc: 0.964 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.50% | train_error: 0.369 | train_acc: 0.964 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.60% | train_error: 0.364 | train_acc: 0.965 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.70% | train_error: 0.372 | train_acc: 0.964 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.80% | train_error: 0.368 | train_acc: 0.964 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.90% | train_error: 0.362 | train_acc: 0.965 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.00% | train_error: 0.364 | train_acc: 0.965 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.10% | train_error: 0.355 | train_acc: 0.966 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.20% | train_error: 0.356 | train_acc: 0.966 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.30% | train_error: 0.349 | train_acc: 0.966 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.40% | train_error: 0.341 | train_acc: 0.967 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.50% | train_error: 0.347 | train_acc: 0.966 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.60% | train_error: 0.349 | train_acc: 0.966 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.70% | train_error: 0.345 | train_acc: 0.967 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.80% | train_error: 0.346 | train_acc: 0.967 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.90% | train_error: 0.338 | train_acc: 0.968 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.00% | train_error: 0.348 | train_acc: 0.966 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.10% | train_error: 0.344 | train_acc: 0.967 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.20% | train_error: 0.346 | train_acc: 0.967 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.30% | train_error: 0.340 | train_acc: 0.967 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.40% | train_error: 0.339 | train_acc: 0.967 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.50% | train_error: 0.336 | train_acc: 0.968 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.60% | train_error: 0.343 | train_acc: 0.967 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.70% | train_error: 0.336 | train_acc: 0.968 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.80% | train_error: 0.339 | train_acc: 0.967 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.90% | train_error: 0.330 | train_acc: 0.968 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.00% | train_error: 0.338 | train_acc: 0.967 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.10% | train_error: 0.328 | train_acc: 0.969 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.20% | train_error: 0.326 | train_acc: 0.969 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.30% | train_error: 0.317 | train_acc: 0.969 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.40% | train_error: 0.329 | train_acc: 0.968 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.50% | train_error: 0.317 | train_acc: 0.969 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.60% | train_error: 0.316 | train_acc: 0.970 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.70% | train_error: 0.318 | train_acc: 0.969 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.80% | train_error: 0.315 | train_acc: 0.970 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.90% | train_error: 0.309 | train_acc: 0.970 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.00% | train_error: 0.308 | train_acc: 0.970 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.10% | train_error: 0.296 | train_acc: 0.972 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.20% | train_error: 0.302 | train_acc: 0.971 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.30% | train_error: 0.298 | train_acc: 0.971 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.40% | train_error: 0.300 | train_acc: 0.971 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.50% | train_error: 0.296 | train_acc: 0.971 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.60% | train_error: 0.291 | train_acc: 0.972 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.70% | train_error: 0.287 | train_acc: 0.972 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.80% | train_error: 0.283 | train_acc: 0.973 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.90% | train_error: 0.280 | train_acc: 0.973 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.00% | train_error: 0.285 | train_acc: 0.973 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.10% | train_error: 0.277 | train_acc: 0.973 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.20% | train_error: 0.292 | train_acc: 0.972 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.30% | train_error: 0.289 | train_acc: 0.972 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.40% | train_error: 0.292 | train_acc: 0.972 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.50% | train_error: 0.287 | train_acc: 0.972 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.60% | train_error: 0.285 | train_acc: 0.973 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.70% | train_error: 0.280 | train_acc: 0.973 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.80% | train_error: 0.283 | train_acc: 0.973 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.90% | train_error: 0.277 | train_acc: 0.973 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.00% | train_error: 0.285 | train_acc: 0.973 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.10% | train_error: 0.278 | train_acc: 0.973 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.20% | train_error: 0.266 | train_acc: 0.974 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.30% | train_error: 0.264 | train_acc: 0.975 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.40% | train_error: 0.271 | train_acc: 0.974 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.50% | train_error: 0.265 | train_acc: 0.974 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.60% | train_error: 0.265 | train_acc: 0.974 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.70% | train_error: 0.258 | train_acc: 0.975 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.80% | train_error: 0.263 | train_acc: 0.975 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.90% | train_error: 0.251 | train_acc: 0.976 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.00% | train_error: 0.248 | train_acc: 0.976 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.10% | train_error: 0.248 | train_acc: 0.976 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.20% | train_error: 0.250 | train_acc: 0.976 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.30% | train_error: 0.243 | train_acc: 0.977 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.40% | train_error: 0.241 | train_acc: 0.977 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.50% | train_error: 0.239 | train_acc: 0.977 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.60% | train_error: 0.240 | train_acc: 0.977 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.70% | train_error: 0.239 | train_acc: 0.977 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.80% | train_error: 0.239 | train_acc: 0.977 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.90% | train_error: 0.235 | train_acc: 0.977 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.00% | train_error: 0.233 | train_acc: 0.978 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.10% | train_error: 0.234 | train_acc: 0.977 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.20% | train_error: 0.240 | train_acc: 0.977 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.30% | train_error: 0.238 | train_acc: 0.977 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.40% | train_error: 0.226 | train_acc: 0.978 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.50% | train_error: 0.226 | train_acc: 0.978 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.60% | train_error: 0.229 | train_acc: 0.978 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.70% | train_error: 0.226 | train_acc: 0.978 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.80% | train_error: 0.218 | train_acc: 0.979 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.90% | train_error: 0.219 | train_acc: 0.979 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.00% | train_error: 0.220 | train_acc: 0.979 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.10% | train_error: 0.216 | train_acc: 0.979 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.20% | train_error: 0.217 | train_acc: 0.979 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.30% | train_error: 0.216 | train_acc: 0.979 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.40% | train_error: 0.216 | train_acc: 0.979 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.50% | train_error: 0.213 | train_acc: 0.979 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.60% | train_error: 0.213 | train_acc: 0.979 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.70% | train_error: 0.213 | train_acc: 0.979 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.80% | train_error: 0.205 | train_acc: 0.980 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.90% | train_error: 0.210 | train_acc: 0.980 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.00% | train_error: 0.211 | train_acc: 0.980 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.10% | train_error: 0.209 | train_acc: 0.980 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.20% | train_error: 0.206 | train_acc: 0.980 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.30% | train_error: 0.204 | train_acc: 0.980 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.40% | train_error: 0.210 | train_acc: 0.980 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.50% | train_error: 0.198 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.60% | train_error: 0.198 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.70% | train_error: 0.202 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.80% | train_error: 0.201 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.90% | train_error: 0.202 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.00% | train_error: 0.195 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.10% | train_error: 0.203 | train_acc: 0.980 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.20% | train_error: 0.197 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.30% | train_error: 0.201 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.40% | train_error: 0.187 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.50% | train_error: 0.197 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.60% | train_error: 0.187 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.70% | train_error: 0.195 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.80% | train_error: 0.195 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.90% | train_error: 0.190 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.00% | train_error: 0.190 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.10% | train_error: 0.194 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.20% | train_error: 0.187 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.30% | train_error: 0.190 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.40% | train_error: 0.190 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.50% | train_error: 0.195 | train_acc: 0.981 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.60% | train_error: 0.188 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.70% | train_error: 0.188 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.80% | train_error: 0.190 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.90% | train_error: 0.191 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.00% | train_error: 0.188 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.10% | train_error: 0.189 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.20% | train_error: 0.175 | train_acc: 0.983 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.30% | train_error: 0.189 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.40% | train_error: 0.183 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.50% | train_error: 0.189 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.60% | train_error: 0.181 | train_acc: 0.983 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.70% | train_error: 0.188 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.80% | train_error: 0.179 | train_acc: 0.983 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.90% | train_error: 0.190 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.00% | train_error: 0.186 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.10% | train_error: 0.185 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.20% | train_error: 0.182 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.30% | train_error: 0.182 | train_acc: 0.982 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.40% | train_error: 0.171 | train_acc: 0.984 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.50% | train_error: 0.178 | train_acc: 0.983 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.60% | train_error: 0.170 | train_acc: 0.984 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.70% | train_error: 0.181 | train_acc: 0.983 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.80% | train_error: 0.166 | train_acc: 0.984 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.90% | train_error: 0.175 | train_acc: 0.983 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.00% | train_error: 0.173 | train_acc: 0.983 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.10% | train_error: 0.173 | train_acc: 0.983 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.20% | train_error: 0.171 | train_acc: 0.984 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.30% | train_error: 0.168 | train_acc: 0.984 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.40% | train_error: 0.167 | train_acc: 0.984 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.50% | train_error: 0.174 | train_acc: 0.983 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.60% | train_error: 0.158 | train_acc: 0.985 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.70% | train_error: 0.173 | train_acc: 0.983 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.80% | train_error: 0.164 | train_acc: 0.984 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.90% | train_error: 0.175 | train_acc: 0.983 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================================>] 100.0% | train_error: 0.175 | train_acc: 0.983 " ] } ], "source": [ "from sklearn.datasets import load_digits\n", "\n", "def onehot(target: np.ndarray):\n", " onehot = np.zeros((target.size, target.max() + 1))\n", " onehot[np.arange(target.size), target] = 1\n", " return onehot\n", "\n", "digits = load_digits()\n", "\n", "X = digits.data\n", "target = digits.target\n", "target = onehot(target)\n", "\n", "input_nodes = 64\n", "hidden_nodes1 = 100\n", "hidden_nodes2 = 30\n", "output_nodes = 10\n", "\n", "dims = (input_nodes, hidden_nodes1, hidden_nodes2, output_nodes)\n", "\n", "multiclass = FFNN(dims, hidden_func=LRELU, output_func=softmax, cost_func=CostCrossEntropy)\n", "\n", "multiclass.reset_weights() # reset weights such that previous runs or reruns don't affect the weights\n", "\n", "scheduler = Adam(eta=1e-4, rho=0.9, rho2=0.999)\n", "scores = multiclass.fit(X, target, scheduler, epochs=1000)" ] }, { "cell_type": "markdown", "id": "8e208051", "metadata": {}, "source": [ "## Testing the XOR gate and other gates\n", "\n", "Let us now use our code to test the XOR gate." ] }, { "cell_type": "code", "execution_count": 21, "id": "db016d41", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Adam: Eta=0.1, Lambda=0\n", "\r", " [----------------------------------------] 0.000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.1000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.2000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.3000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.4000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.5000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.6000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.7000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.8000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 0.9000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.100% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.200% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.300% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.400% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.500% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.600% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.700% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.800% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 1.900% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.100% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.200% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.300% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [----------------------------------------] 2.400% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.500% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.600% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.700% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.800% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 2.900% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.100% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.200% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.300% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.400% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.500% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.600% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.700% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.800% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 3.900% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.100% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.200% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.300% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.400% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.500% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.600% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.700% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.800% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [>---------------------------------------] 4.900% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.100% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.200% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.300% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.400% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.500% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.600% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.700% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.800% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 5.900% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.100% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.200% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.300% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.400% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.500% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.600% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.700% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.800% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 6.900% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.100% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.200% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.300% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=>--------------------------------------] 7.400% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.500% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.600% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.700% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.800% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 7.900% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.100% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.200% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.300% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.400% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.500% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.600% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.700% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.800% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 8.900% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.000% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.100% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.200% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.300% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.400% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.500% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.600% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.700% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.800% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==>-------------------------------------] 9.900% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 10.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 11.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===>------------------------------------] 12.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 12.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 13.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====>-----------------------------------] 14.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 15.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 16.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====>----------------------------------] 17.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 17.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 18.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======>---------------------------------] 19.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 20.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 21.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======>--------------------------------] 22.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 22.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 23.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========>-------------------------------] 24.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 25.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 26.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========>------------------------------] 27.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 27.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 28.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========>-----------------------------] 29.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 30.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 31.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========>----------------------------] 32.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 32.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 33.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============>---------------------------] 34.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 35.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 36.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============>--------------------------] 37.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 37.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 38.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============>-------------------------] 39.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 40.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 41.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============>------------------------] 42.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 42.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 43.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================>-----------------------] 44.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 45.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 46.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================>----------------------] 47.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 47.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 48.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.10% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.30% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.50% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.70% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================>---------------------] 49.90% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 50.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 51.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================>--------------------] 52.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 52.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 53.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================>-------------------] 54.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 55.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 56.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================>------------------] 57.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 57.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 58.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================>-----------------] 59.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 60.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 61.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================>----------------] 62.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 62.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 63.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [========================>---------------] 64.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 65.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 66.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=========================>--------------] 67.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 67.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 68.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==========================>-------------] 69.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 70.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 71.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===========================>------------] 72.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 72.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 73.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.60% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.80% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [============================>-----------] 74.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.00% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.20% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.40% | train_error: 10.4 | train_acc: 0.500 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 75.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 76.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=============================>----------] 77.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 77.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 78.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==============================>---------] 79.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 80.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 81.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===============================>--------] 82.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 82.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 83.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [================================>-------] 84.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 85.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 86.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=================================>------] 87.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 87.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 88.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [==================================>-----] 89.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 90.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 91.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [===================================>----] 92.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 92.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 93.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [====================================>---] 94.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 95.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 96.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=====================================>--] 97.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 97.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 98.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.00% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.10% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.20% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.30% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.40% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.50% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.60% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.70% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.80% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [======================================>-] 99.90% | train_error: -0.0000000010 | train_acc: 1.00 " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " " ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " [=======================================>] 100.0% | train_error: -0.0000000010 | train_acc: 1.00 " ] } ], "source": [ "X = np.array([ [0, 0], [0, 1], [1, 0],[1, 1]],dtype=np.float64)\n", "\n", "# The XOR gate\n", "yXOR = np.array( [[ 0], [1] ,[1], [0]])\n", "\n", "input_nodes = X.shape[1]\n", "output_nodes = 1\n", "\n", "logistic_regression = FFNN((input_nodes, output_nodes), output_func=sigmoid, cost_func=CostLogReg, seed=2023)\n", "logistic_regression.reset_weights() # reset weights such that previous runs or reruns don't affect the weights\n", "scheduler = Adam(eta=1e-1, rho=0.9, rho2=0.999)\n", "scores = logistic_regression.fit(X, yXOR, scheduler, epochs=1000)" ] }, { "cell_type": "markdown", "id": "d1384449", "metadata": {}, "source": [ "Not bad, but the results depend strongly on the learning reate. Try different learning rates." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.9.10" } }, "nbformat": 4, "nbformat_minor": 5 }