diff --git a/week4/exercises/Lecture13_TrainingDeepNNs_Exercises_no_solutions.ipynb b/week4/exercises/Lecture13_TrainingDeepNNs_Exercises_no_solutions.ipynb new file mode 100644 index 0000000..3619192 --- /dev/null +++ b/week4/exercises/Lecture13_TrainingDeepNNs_Exercises_no_solutions.ipynb @@ -0,0 +1 @@ +{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Exercises for Lecture 13 (Training deep neural networks)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import numpy as np\n", "\n", "# To plot pretty figures\n", "%matplotlib inline\n", "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", "mpl.rc('axes', labelsize=14)\n", "mpl.rc('xtick', labelsize=12)\n", "mpl.rc('ytick', labelsize=12)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["## Exercise 1: Build a deep neural network with ELU activation functions and batch normalisation and apply it to fashion MINST."]}, {"cell_type": "markdown", "metadata": {}, "source": ["How good of an accuracy can you achieve on the test set?"]}], "metadata": {"celltoolbar": "Tags", "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.11.7"}}, "nbformat": 4, "nbformat_minor": 4} \ No newline at end of file diff --git a/week4/exercises/Lecture14_CNN_Exercises_no_solutions.ipynb b/week4/exercises/Lecture14_CNN_Exercises_no_solutions.ipynb new file mode 100644 index 0000000..ff95fda --- /dev/null +++ b/week4/exercises/Lecture14_CNN_Exercises_no_solutions.ipynb @@ -0,0 +1 @@ +{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Exercises for Lecture 14 (Convolutional neural networks)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import numpy as np\n", "import tensorflow as tf\n", "from tensorflow import keras\n", "\n", "# To make this notebook's output stable across runs\n", "def reset_state(seed=42):\n", " tf.keras.backend.clear_session()\n", " tf.random.set_seed(seed)\n", " np.random.seed(seed)"]}, {"cell_type": "markdown", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["## Exercise 1: Build a deeper CNN architecture for fashion MNIST than considered in the corresponding lecture to achieves a better classification accuracy."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Following the guiding CNN design principles covered in the lecture to construct a better CNN architecture."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Load and set up data."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["# Load fashion MNIST data\n", "(X_train_full, y_train_full), (X_test, y_test) = keras.datasets.fashion_mnist.load_data()\n", "X_train, X_valid = X_train_full[:-30000], X_train_full[-30000:]\n", "y_train, y_valid = y_train_full[:-30000], y_train_full[-30000:]\n", "\n", "# Standardize\n", "X_mean = X_train.mean(axis=0, keepdims=True)\n", "X_std = X_train.std(axis=0, keepdims=True) + 1e-7\n", "X_train = (X_train - X_mean) / X_std\n", "X_valid = (X_valid - X_mean) / X_std\n", "X_test = (X_test - X_mean) / X_std\n", "\n", "# Add final channel axis (one channel)\n", "X_train = X_train[..., np.newaxis]\n", "X_valid = X_valid[..., np.newaxis]\n", "X_test = X_test[..., np.newaxis]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Build and fit new model, and evaluate its performance."]}], "metadata": {"celltoolbar": "Tags", "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.8.12"}}, "nbformat": 4, "nbformat_minor": 4} \ No newline at end of file diff --git a/week4/exercises/Lecture15_DeepCNN_Exercises_no_solutions.ipynb b/week4/exercises/Lecture15_DeepCNN_Exercises_no_solutions.ipynb new file mode 100644 index 0000000..1f39b73 --- /dev/null +++ b/week4/exercises/Lecture15_DeepCNN_Exercises_no_solutions.ipynb @@ -0,0 +1 @@ +{"cells": [{"cell_type": "markdown", "id": "c1c2c049-4d1c-4a46-b035-b3f477aace8d", "metadata": {}, "source": ["# Exercises for Lecture 15 (Deep CNN architectures)"]}, {"cell_type": "code", "execution_count": null, "id": "ea8f9065-2320-422b-8a8c-a55d7fd726a3", "metadata": {}, "outputs": [], "source": ["import numpy as np\n", "import tensorflow as tf\n", "from tensorflow import keras\n", "from functools import partial\n", "\n", "# To make this notebook's output stable across runs\n", "def reset_state(seed=42):\n", " tf.keras.backend.clear_session()\n", " tf.random.set_seed(seed)\n", " np.random.seed(seed)"]}, {"cell_type": "markdown", "id": "c5dc69f6-efea-4b71-9746-25ca8d347132", "metadata": {"slideshow": {"slide_type": "subslide"}}, "source": ["## Exercise 1: Build a ResNet CNN architecture for fashion MNIST."]}, {"cell_type": "markdown", "id": "9fa998f5-7e8e-4cd6-a335-13a146c49de3", "metadata": {}, "source": ["Load and set up data."]}, {"cell_type": "code", "execution_count": null, "id": "b7fd0854-0e6f-4d4a-838b-506c4a26268c", "metadata": {}, "outputs": [], "source": ["# Load fashion MNIST data\n", "(X_train_full, y_train_full), (X_test, y_test) = keras.datasets.fashion_mnist.load_data()\n", "X_train, X_valid = X_train_full[:-30000], X_train_full[-30000:]\n", "y_train, y_valid = y_train_full[:-30000], y_train_full[-30000:]\n", "\n", "# Standardize\n", "X_mean = X_train.mean(axis=0, keepdims=True)\n", "X_std = X_train.std(axis=0, keepdims=True) + 1e-7\n", "X_train = (X_train - X_mean) / X_std\n", "X_valid = (X_valid - X_mean) / X_std\n", "X_test = (X_test - X_mean) / X_std\n", "\n", "# Add final channel axis (one channel)\n", "X_train = X_train[..., np.newaxis]\n", "X_valid = X_valid[..., np.newaxis]\n", "X_test = X_test[..., np.newaxis]"]}, {"cell_type": "markdown", "id": "4362c522-3172-4fc9-9265-761cccad73cc", "metadata": {}, "source": ["Use the subclassing API to define a `ResidualUnit` layer."]}, {"cell_type": "markdown", "id": "dd33a8d1-af2f-49cc-ad73-8b447c07955f", "metadata": {}, "source": ["Buid a ResNet model using the layer you defined above."]}, {"cell_type": "markdown", "id": "561c8d32-b8e4-426b-8092-7ec79432dde0", "metadata": {}, "source": ["Compile your model and train it."]}, {"cell_type": "markdown", "id": "1159fce2-0749-4170-ab4d-f4b8e0ed6014", "metadata": {}, "source": ["Evaluate the model performance on the test set."]}], "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.8.12"}}, "nbformat": 4, "nbformat_minor": 5} \ No newline at end of file diff --git a/week4/slides/Lecture10_ANN.ipynb b/week4/slides/Lecture10_ANN.ipynb new file mode 100644 index 0000000..d7bc303 --- /dev/null +++ b/week4/slides/Lecture10_ANN.ipynb @@ -0,0 +1,1047 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Lecture 10: Artificial neural networks (ANNs)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "![](https://www.tensorflow.org/images/colab_logo_32px.png)\n", + "[Run in colab](https://colab.research.google.com/drive/1PKCyhLqpAeBA3u8yurcgCeaFYcKZNnQE)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:22.727146Z", + "iopub.status.busy": "2024-01-10T00:20:22.726716Z", + "iopub.status.idle": "2024-01-10T00:20:22.735610Z", + "shell.execute_reply": "2024-01-10T00:20:22.735071Z" + }, + "slideshow": { + "slide_type": "skip" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Last executed: 2024-01-10 00:20:22\n" + ] + } + ], + "source": [ + "import datetime\n", + "now = datetime.datetime.now()\n", + "print(\"Last executed: \" + now.strftime(\"%Y-%m-%d %H:%M:%S\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Biological inspiration" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Architecture of neural networks originally inspired by the brain.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Rewriting the brain\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "Study performed with ferrets by [Roe et al. (1992)](https://www.ncbi.nlm.nih.gov/pubmed/1527604).\n", + "\n", + "[[Image credit](https://www.coursera.org/learn/machine-learning)]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "\n", + "\n", + "Study performed with hamsters by [Metin & Frost (1989)](https://www.ncbi.nlm.nih.gov/pubmed/2911580).\n", + "\n", + "[[Image credit](https://www.coursera.org/learn/machine-learning)]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Led to \"*one learning algorithm*\" hypothesis." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Biological neurons" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "-" + } + }, + "source": [ + "\n", + "\n", + "[Image credit: [Bruce Blaus, Wikipedia](https://en.wikipedia.org/wiki/Neuron)]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Biological neurons consist of cell body containing nucleus, dentrite branches (inputs) and axon (output). \n", + "\n", + "Axon connects neurons and the length of the axon can be a few to 10,000 times the size of the cell body.\n", + "\n", + "Axon splits into telodendria branch, with synaptic terminals at ends, which are connected to dendrites of other neurons.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Although biological neurons rather simple, complexity comes from networks of billions of neurons, each connected to thousands of other neurons." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Artificial neurons (units)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Perceptron" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "-" + } + }, + "source": [ + "\n", + "\n", + "[[Image credit](https://blog.dbrgn.ch/2013/3/26/perceptrons-in-python/)]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### General logistic unit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Weighted sum*:\n", + "\n", + "$$z = \\sum_{j=1}^n \\theta_j x_j =\\theta^{\\rm T} x.$$\n", + "\n", + "*Activations*:\n", + "$a = h(z),$\n", + "for non-linear activation function $h$." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Generally we refer to as a logistic unit (rather than an artificial neuron) since additional generalities than concepts motivated by biology will be considered." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Examples of activation functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Step\n", + "\n", + "$$ a(z) = \\biggl \\{\n", + "\\begin{split}\n", + "0,\\ \\text{if}\\ z < 0\\\\\n", + "1,\\ \\text{if}\\ z \\geq 0 \\\\\n", + "\\end{split}\n", + "$$\n", + "\n", + "Sigmoid\n", + "\n", + "$$\n", + "a(z) = \\frac{1}{1+\\exp{(-z)}}\n", + "$$\n", + "\n", + "Hyperboic tangent\n", + "\n", + "$$\n", + "a(z) = \\tanh(z)\n", + "$$\n", + "\n", + "Rectified linear unit (ReLU)\n", + "\n", + "$$\n", + "a(z) = \\max(0, z)\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "#### Gradients of activation functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice the step function has zero gradient." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + }, + "tags": [ + "exercise_pointer" + ] + }, + "source": [ + "**Exercises:** *You can now complete Exercise 1-2 in the exercises associated with this lecture.*" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Neural network" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Construct artifical neural network by combining layers of multiple logistic units." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Weighted sums*:\n", + "$\n", + "z_j = \\sum_{i=1}^n \\theta_{ij} x_i\n", + "$\n", + "\n", + "*Activations*:\n", + "$\n", + "a_j = h(z_j)\n", + "$\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Architectures and terminology" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "[[Image credit](https://medium.com/@xenonstack/overview-of-artificial-neural-networks-and-its-applications-2525c1addff7)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Networks can be wide/narrow and deep/shallow.\n", + "\n", + "Here we consider feedforward network only. Other configurations can also be considered, as we will see later in the course." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Universal approximation theorem" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The *universal approximation theorem* states that a feedforward network *can* accurately approximate any continuous function from one finite dimensional space to another, given enough hidden units (Hornik et al. 1989, Cybenko 1989).\n", + "\n", + "(Some technical caveats that are beyond the scope of this course regarding properties of the mapping and activation functions.)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "ANNs thus have the *potential* to be universal approximators. \n", + "\n", + "Universal approximation theorem does *not* provide any guarantee that training finds this representation." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Multi-class classification" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Multi-class classification can be easily performed with an ANN, where each output node corresponds to a certain class." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "[[Image credit (adapted)](https://medium.com/@xenonstack/overview-of-artificial-neural-networks-and-its-applications-2525c1addff7)]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Set up training data as unit vectors, with 1 for the target class and 0 for all other classes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Softmax" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "-" + } + }, + "source": [ + "Map predictions to *\"probabilities\"* using the softmax function for all output nodes with activiations $a_j$:\n", + "\n", + "$$ \n", + "\\hat{p}_j = \\frac{\\exp(a_j)}{\\sum_{j^\\prime} \\exp(a_{j^\\prime})}\n", + ".\n", + "$$\n", + "\n", + "Normalised such that\n", + "- $\\sum_j \\hat{p}_j=1$\n", + "- $0 \\leq \\hat{p}_j \\leq 1$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Cost functions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Appropriate cost functions depend on whether performing regression or classification. Consider targets $y_j^{(i)}$ and outputs (predictions) of ANN $\\hat{p}_j^{(i)}$, for training instance $i$ and output node $j$." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Typical cost function for regression is the mean square error: \n", + "\n", + "$$\\text{MSE}(\\Theta) = \\frac{1}{m} \\sum_{i} \\sum_{j} \\left(\\hat{p}_j^{(i)} - y_j^{(i)}\\right)^2 .$$\n", + "\n", + "Typical cost function for classification is cross-entropy:\n", + "\n", + "$$\n", + "C(\\Theta) = -\\frac{1}{m} \\sum_{i} \\sum_{j} y_j^{(i)} \\log \\left(\\hat{p}_j^{(i)}\\right)\n", + ".\n", + "$$\n", + "\n", + "(Although other cost functions are used widely.)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Various forms of regularisation often considered, e.g. $\\ell_2$ regularisation." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Error surface non-convex, potentially with many local optima. Historically training ANNs has been difficult." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Backpropagation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Problem\n", + "\n", + "To train ANN's want to exploit gradient of error surface (e.g. for gradient descent algorithms). Therefore need an efficient method to compute gradients." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Backpropagation algorithm developed by [Rumelhart, Hinton & Williams (1986)](https://www.nature.com/articles/323533a0) to efficiently compute the gradient of the error surface (i.e. cost function) with respect to each weight of the network.\n", + "\n", + "Gradients then accessible for training." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Overview of backpropagation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Backpropagation consists of forward and reverse (backwards) passes (hence name).\n", + "\n", + "Consider each training instance. A forward run of the network is applied to compute the output error $\\epsilon$. Then errors are backpropagated through the network to compute the rate of change of the error with respect to the weights of the network." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "In practice, error gradients $\\frac{\\partial \\epsilon}{\\partial z_j}$ are computed and backpropagated, from which error gradients with respect to the weights can be computed $\\frac{\\partial \\epsilon}{\\partial \\theta_{ij}}$." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Backpropagation algorithm follows from a straightforward application of the chain rule." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Define network architecture and notation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Now make network layer explicit in notation.\n", + "\n", + "Weighted sum:\n", + "$\n", + "z_j^l = \\sum_i \\theta_{ij}^l a_i^{l-1} ,\n", + "$\n", + "where $\\theta_{ij}^l$ is the weight between node $i$ at layer $l-1$ and node $j$ at layer $l$ (note that difference conventions are often used, e.g. $\\theta_{ji}^{l-1}$ for the same connection). Consider $L$ layers.\n", + "\n", + "Activations:\n", + "$\n", + "a_i^l = h(z_i^l) .\n", + "$\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Backpropagation calculations\n", + "\n", + "Want to compute\n", + "\n", + "$$\\Delta \\theta_{ij}^l = -\\eta \\frac{\\partial \\epsilon}{\\partial \\theta_{ij}^l}.$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "By chain rule:\n", + "\n", + "$$\\frac{\\partial \\epsilon}{\\partial \\theta_{ij}^l}=\\frac{\\partial \\epsilon}{\\partial z_{j}^l}\\frac{\\partial z_{j}^l}{\\partial \\theta_{ij}^l}=\\frac{\\partial \\epsilon}{\\partial z_{j}^l}a_{i}^{l-1}=\\delta_{i}^l a_{i}^{l-1}, $$\n", + "\n", + "where $\\delta_i^l = \\frac{\\partial \\epsilon}{\\partial z_{j}^l}$\n", + "\n", + "$\\left(\n", + "\\text{recall}\\ \n", + "z_j^l = \\sum_i \\theta_{ij}^l a_i^{l-1}\n", + "\\right)$." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Now need to compute\n", + "\n", + "$$\\delta_i^l = \\frac{\\partial \\epsilon}{\\partial z_{j}^l} .$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "#### Functional dependence\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "By chain rule again:\n", + "\n", + "$$\\delta_i^l = \\frac{\\partial \\epsilon}{\\partial z_{j}^l} = \\sum_i \\frac{\\partial \\epsilon}{\\partial z_{i}^{l+1}} \\frac{\\partial z_{i}^{l+1}}{\\partial a_{j}^l} \\frac{\\partial a_{j}^l}{\\partial z_{j}^l} = \\sum_i \\delta_i^{l+1} \\theta_{ji}^{l+1} h^\\prime(z_j^l).$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Note the term $h^\\prime(z_j^l)$ is independent of $i$ and so can be moved outside the summation." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Boundary condition:\n", + "\n", + "$$\\delta_i^L = \\frac{\\partial \\epsilon}{\\partial z_{j}^L} = \\frac{\\partial \\epsilon}{\\partial a_{j}^L} \\frac{\\partial a_{j}^L}{\\partial z_{j}^L} = \\frac{\\partial \\epsilon}{\\partial a_{j}^L} h^\\prime(z_j^L).$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Summary of backpropagation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For current set of weights $\\theta_{ij}^l$, compute forward pass through network:\n", + "\n", + "$$z_j^l = \\sum_i \\theta_{ij}^l a_i^{l-1} ,$$\n", + "\n", + "$$a_i^l = h(z_i^l) .$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Propagate errors backwards through network:\n", + "\n", + "$$\\delta_i^l = \\frac{\\partial \\epsilon}{\\partial z_{j}^l}=\\sum_i \\delta_i^{l+1} \\theta_{ji}^{l+1} h^\\prime(z_j^l) .$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Compute derivatives of error with respect to weights:\n", + "\n", + "$$\\frac{\\partial \\epsilon}{\\partial \\theta_{ij}^l} = \\delta_i^l a_i^{l-1}.$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Training with backpropagation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Backpropagation simply computes derivatives of error with respect to weights.\n", + "\n", + "Still need training algorithm to update weights given derivatives, e.g. $\\Delta \\theta_{ij}^l = -\\eta \\frac{\\partial \\epsilon}{\\partial \\theta_{ij}^l}.$ \n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Various approaches can be considered:\n", + "- Online: update weights after each training instance.\n", + "- Full-batch: update weights after full sweep through training data.\n", + "- Mini-batch: update weights after a small sample of training cases." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "#### Example\n", + "\n", + "Scikit-learn now supports ANNs but not intended for large scale problems. \n", + "\n", + "Trains using some form of gradient descent, with gradients computed by backpropagation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:22.781603Z", + "iopub.status.busy": "2024-01-10T00:20:22.781145Z", + "iopub.status.idle": "2024-01-10T00:20:23.161352Z", + "shell.execute_reply": "2024-01-10T00:20:23.160637Z" + } + }, + "outputs": [], + "source": [ + "# disable convergence warning from early stopping\n", + "from warnings import simplefilter\n", + "from sklearn.exceptions import ConvergenceWarning\n", + "simplefilter(\"ignore\", category=ConvergenceWarning)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:23.165008Z", + "iopub.status.busy": "2024-01-10T00:20:23.164451Z", + "iopub.status.idle": "2024-01-10T00:20:38.093599Z", + "shell.execute_reply": "2024-01-10T00:20:38.092993Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 1, loss = 0.32009978\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 2, loss = 0.15347534\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 3, loss = 0.11544755\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 4, loss = 0.09279764\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 5, loss = 0.07889367\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 6, loss = 0.07170497\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 7, loss = 0.06282111\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 8, loss = 0.05530788\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 9, loss = 0.04960484\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 10, loss = 0.04645355\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training set score: 0.986800\n", + "Test set score: 0.970000\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from sklearn.datasets import fetch_openml\n", + "from sklearn.neural_network import MLPClassifier\n", + "\n", + "mnist = fetch_openml('mnist_784', version=1, cache=True, parser='auto')\n", + "# rescale the data, use the traditional train/test split\n", + "X, y = mnist.data / 255., mnist.target\n", + "X_train, X_test = X[:60000], X[60000:]\n", + "y_train, y_test = y[:60000], y[60000:]\n", + "\n", + "mlp = MLPClassifier(hidden_layer_sizes=(50,), max_iter=10, alpha=1e-4,\n", + " solver='sgd', verbose=10, tol=1e-4, random_state=1,\n", + " learning_rate_init=.1)\n", + "\n", + "mlp.fit(X_train, y_train)\n", + "print(\"Training set score: %f\" % mlp.score(X_train, y_train))\n", + "print(\"Test set score: %f\" % mlp.score(X_test, y_test))" + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "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.8.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/week4/slides/Lecture11_IntroToTensorFlow.ipynb b/week4/slides/Lecture11_IntroToTensorFlow.ipynb new file mode 100644 index 0000000..a1eef7b --- /dev/null +++ b/week4/slides/Lecture11_IntroToTensorFlow.ipynb @@ -0,0 +1,1915 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Lecture 11: Introduction to TensorFlow" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "![](https://www.tensorflow.org/images/colab_logo_32px.png)\n", + "[Run in colab](https://colab.research.google.com/drive/1H8iqFsQn9FuoNregKha7MJAQVp_eT77-)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:45.682771Z", + "iopub.status.busy": "2024-01-10T00:20:45.682383Z", + "iopub.status.idle": "2024-01-10T00:20:45.691614Z", + "shell.execute_reply": "2024-01-10T00:20:45.691076Z" + }, + "slideshow": { + "slide_type": "skip" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Last executed: 2024-01-10 00:20:45\n" + ] + } + ], + "source": [ + "import datetime\n", + "now = datetime.datetime.now()\n", + "print(\"Last executed: \" + now.strftime(\"%Y-%m-%d %H:%M:%S\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Overview of TensorFlow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[TensorFlow](https://www.tensorflow.org/) is an open source library developed by Google for numerical computation. It is particularly well suited for large-scale machine learning. \n", + "\n", + "TensorFlow is based on the construction of *computational graphs*. It has evolved considerably since it's open source release in 2015. We will use TF2, which offers many additional features built on top of core features (the most important is `tf.keras` discussed in later lectures)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:45.730161Z", + "iopub.status.busy": "2024-01-10T00:20:45.729719Z", + "iopub.status.idle": "2024-01-10T00:20:49.187358Z", + "shell.execute_reply": "2024-01-10T00:20:49.186619Z" + }, + "slideshow": { + "slide_type": "skip" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-01-10 00:20:46.295156: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2024-01-10 00:20:46.707194: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2024-01-10 00:20:46.709789: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-01-10 00:20:47.698046: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow import keras" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Features \n", + "\n", + "- Similar to [`numpy`](https://numpy.org/doc/stable/) but with GPU support.\n", + "- Supports distributed computing.\n", + "- Includes a kind of just-in-time (JIT) compiler to optimise speed and memory usage.\n", + "- Computational graphs can be saved and exported.\n", + "- Supports autodiff and provides numerous advanced optimisers." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### TensorFlow's Python API\n", + "\n", + "
\n", + "\n", + "\n", + "\n", + "[Credit: Geron]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### TensorFlow's Architecture\n", + "\n", + "
\n", + "\n", + "\n", + "\n", + "[Credit: Geron]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "At lowest level TensorFlow is implemented in C++ so that it is highly efficient." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will focus solely on the python TensorFlow interfaces (typical approach). Most of the time you will simple need to interact with the Keras interface but sometimes you might want to use the low-level python API for greater flexibility." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Hardware" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the factors responsible for the dramatic recent growth of machine learning is advances in computing power. \n", + "\n", + "In particular, hardware that supports high levels of parallelism." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "- Central Processing Unit (CPU):\n", + " - General purpose \n", + " - Low latency \n", + " - Low throughput\n", + " - Sequential\n", + " \n", + "- Graphics Processing Unit (GPU)\n", + " - Specialised (for graphics initially)\n", + " - High latency \n", + " - High throughput\n", + " - Parallel execution\n", + " \n", + "- Tensor Processing Unit (TPU)\n", + " - Specialised for matrix operations\n", + " - High latency\n", + " - Very high throughput\n", + " - Extreme parallel execution" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "In TensorFlow many operations are implemented in low-level kernels, optimised for specific hardware, e.g. CPUs, GPUS, or TPUs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TensorFlow's execution engine will ensure operations are run efficiently (across multiple machines and devices if set up accordingly)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "[Credit: Geron]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "#### Aside: chips optimised for machine learning are an active area of development\n", + "\n", + "Google developed TPU.\n", + "\n", + "[Graphcore](https://www.graphcore.ai/) have developed the Intelligence Processing Unit (IPU)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Computational graphs\n", + "\n", + "\n", + "\n", + "[Credit: Geron]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "User code constructs the computational graph (can be constructed in Python). With TensorFlow 2, graph construction is less explicit and much simpler.\n", + "\n", + "TensorFlow takes computational graph and runs it efficiently via optimized C++ code." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Parallel and distributed computation\n", + "\n", + "\n", + "\n", + "[Credit: Geron]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Computational graphs can be broken up into different chunks, which are then run in parallel across many CPUs/GPUs/TPUs (or highly distributed systems).\n", + "\n", + "This approach allows TensorFlow to scale to big-data." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Scaling to big-data\n", + "\n", + "For example, TensorFlow can be used to train neural networks with millions of parameters and training sets with billions of training instances.\n", + "\n", + "Provides the infrastructure behind many of Google's large-scale machine learning products, e.g. Google Search, Google Photos, ..." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Tensors and operations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TensorFlow API centers around \"Tensors\" (essentially multi-dimensional arrays of matrices), hence its name." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similar to numpy [`ndarray`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Tensors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Can construct constant tensors with `tf.constant`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.192536Z", + "iopub.status.busy": "2024-01-10T00:20:49.191777Z", + "iopub.status.idle": "2024-01-10T00:20:49.221646Z", + "shell.execute_reply": "2024-01-10T00:20:49.221051Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tf.constant([[1., 2., 3.], [4., 5., 6.]]) # 2x3 matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.224596Z", + "iopub.status.busy": "2024-01-10T00:20:49.224220Z", + "iopub.status.idle": "2024-01-10T00:20:49.229626Z", + "shell.execute_reply": "2024-01-10T00:20:49.229096Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tf.constant(42) # scalar" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tensors have a shape and data type (dtype)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.232492Z", + "iopub.status.busy": "2024-01-10T00:20:49.232147Z", + "iopub.status.idle": "2024-01-10T00:20:49.236577Z", + "shell.execute_reply": "2024-01-10T00:20:49.236045Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "TensorShape([2, 3])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t = tf.constant([[1., 2., 3.], [4., 5., 6.]])\n", + "t.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.239238Z", + "iopub.status.busy": "2024-01-10T00:20:49.238896Z", + "iopub.status.idle": "2024-01-10T00:20:49.242669Z", + "shell.execute_reply": "2024-01-10T00:20:49.242147Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tf.float32" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.dtype" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Indexing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tensor indexing is very similar to numpy." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.245639Z", + "iopub.status.busy": "2024-01-10T00:20:49.245273Z", + "iopub.status.idle": "2024-01-10T00:20:49.253018Z", + "shell.execute_reply": "2024-01-10T00:20:49.252523Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t[:, 1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.255766Z", + "iopub.status.busy": "2024-01-10T00:20:49.255421Z", + "iopub.status.idle": "2024-01-10T00:20:49.261818Z", + "shell.execute_reply": "2024-01-10T00:20:49.261305Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t[..., 1, tf.newaxis]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Operations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Variety of tensor operations are possible." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.264747Z", + "iopub.status.busy": "2024-01-10T00:20:49.264389Z", + "iopub.status.idle": "2024-01-10T00:20:49.269613Z", + "shell.execute_reply": "2024-01-10T00:20:49.269093Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t + 10" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.272306Z", + "iopub.status.busy": "2024-01-10T00:20:49.271964Z", + "iopub.status.idle": "2024-01-10T00:20:49.277408Z", + "shell.execute_reply": "2024-01-10T00:20:49.276893Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tf.square(t)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.280108Z", + "iopub.status.busy": "2024-01-10T00:20:49.279770Z", + "iopub.status.idle": "2024-01-10T00:20:49.337574Z", + "shell.execute_reply": "2024-01-10T00:20:49.336941Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t @ tf.transpose(t) # matrix multiplication" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Using `keras.backend`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Keras API also includes its own low-level API with similar functionality, which is basically a wrapper for the corresponding TensorFlow operations (more on Keras in next lecture)." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.340932Z", + "iopub.status.busy": "2024-01-10T00:20:49.340368Z", + "iopub.status.idle": "2024-01-10T00:20:49.375908Z", + "shell.execute_reply": "2024-01-10T00:20:49.375217Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tensorflow import keras\n", + "K = keras.backend\n", + "K.square(K.transpose(t)) + 10" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Tensors and Numpy" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "**Note:** From `tf.__version__ == 2.4.0` tensorflow.numpy functionality will be added: https://www.tensorflow.org/api_docs/python/tf/experimental/numpy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Can create a tensor from ndarray." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.379245Z", + "iopub.status.busy": "2024-01-10T00:20:49.378802Z", + "iopub.status.idle": "2024-01-10T00:20:49.386986Z", + "shell.execute_reply": "2024-01-10T00:20:49.386343Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.array([2., 4., 5.])\n", + "tf.constant(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Can convert ndarray to tensor." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.390159Z", + "iopub.status.busy": "2024-01-10T00:20:49.389613Z", + "iopub.status.idle": "2024-01-10T00:20:49.395820Z", + "shell.execute_reply": "2024-01-10T00:20:49.395186Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 2., 3.],\n", + " [4., 5., 6.]], dtype=float32)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.numpy()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Can apply numpy operations to tensors and vice versa." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.398836Z", + "iopub.status.busy": "2024-01-10T00:20:49.398388Z", + "iopub.status.idle": "2024-01-10T00:20:49.402669Z", + "shell.execute_reply": "2024-01-10T00:20:49.402129Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 2., 3.],\n", + " [4., 5., 6.]], dtype=float32)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array(t)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.405317Z", + "iopub.status.busy": "2024-01-10T00:20:49.404889Z", + "iopub.status.idle": "2024-01-10T00:20:49.410243Z", + "shell.execute_reply": "2024-01-10T00:20:49.409597Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tf.square(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.413047Z", + "iopub.status.busy": "2024-01-10T00:20:49.412621Z", + "iopub.status.idle": "2024-01-10T00:20:49.416846Z", + "shell.execute_reply": "2024-01-10T00:20:49.416325Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1., 4., 9.],\n", + " [16., 25., 36.]], dtype=float32)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.square(t)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Conflicting Types" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TensorFlow does not perform type conversions automatically since they can significantly degrade performance and can easily go unnoticed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Therefore you cannot add a float to an integer." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.419883Z", + "iopub.status.busy": "2024-01-10T00:20:49.419332Z", + "iopub.status.idle": "2024-01-10T00:20:49.423300Z", + "shell.execute_reply": "2024-01-10T00:20:49.422795Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cannot compute AddV2 as input #1(zero-based) was expected to be a float tensor but is a int32 tensor [Op:AddV2] name: \n" + ] + } + ], + "source": [ + "try:\n", + " tf.constant(2.0) + tf.constant(40)\n", + "except tf.errors.InvalidArgumentError as ex:\n", + " print(ex)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarly, you cannot add a float (32 bit) and a double (64 bit)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.426756Z", + "iopub.status.busy": "2024-01-10T00:20:49.426032Z", + "iopub.status.idle": "2024-01-10T00:20:49.432204Z", + "shell.execute_reply": "2024-01-10T00:20:49.431684Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cannot compute AddV2 as input #1(zero-based) was expected to be a float tensor but is a double tensor [Op:AddV2] name: \n" + ] + } + ], + "source": [ + "try:\n", + " tf.constant(2.0) + tf.constant(40., dtype=tf.float64)\n", + "except tf.errors.InvalidArgumentError as ex:\n", + " print(ex)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "If you want to consider operations with different types you need to explicitly cast them first." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.435076Z", + "iopub.status.busy": "2024-01-10T00:20:49.434539Z", + "iopub.status.idle": "2024-01-10T00:20:49.440496Z", + "shell.execute_reply": "2024-01-10T00:20:49.439809Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t2 = tf.constant(40., dtype=tf.float64)\n", + "tf.constant(2.0) + tf.cast(t2, tf.float32)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Previous tensors we've considered are constant and immutable so they cannot be changed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also need tensors that can act as variables that can change over time, for example for weights of a neural network that are regularly updated during training." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.443728Z", + "iopub.status.busy": "2024-01-10T00:20:49.443202Z", + "iopub.status.idle": "2024-01-10T00:20:49.452540Z", + "shell.execute_reply": "2024-01-10T00:20:49.451892Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v = tf.Variable([[1., 2., 3.], [4., 5., 6.]])\n", + "v" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Can be modified in place using the `assign` method." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.455522Z", + "iopub.status.busy": "2024-01-10T00:20:49.455092Z", + "iopub.status.idle": "2024-01-10T00:20:49.462111Z", + "shell.execute_reply": "2024-01-10T00:20:49.461451Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v.assign(2 * v)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## TensorFlow Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once TensorFlow has constructed a computational graph, it optimises it (e.g. simplying expressions, pruning unused nodes, etc.).\n", + "\n", + "Consequently, a TensorFlow function will typically run a lot faster than an equivalent numpy function.\n", + "\n", + "`tf.function` can be used to turn a python function into a TensorFlow function." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.465056Z", + "iopub.status.busy": "2024-01-10T00:20:49.464624Z", + "iopub.status.idle": "2024-01-10T00:20:49.467713Z", + "shell.execute_reply": "2024-01-10T00:20:49.467060Z" + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "def cube(x):\n", + " return x ** 3" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.470876Z", + "iopub.status.busy": "2024-01-10T00:20:49.470259Z", + "iopub.status.idle": "2024-01-10T00:20:49.474488Z", + "shell.execute_reply": "2024-01-10T00:20:49.473826Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cube(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.477379Z", + "iopub.status.busy": "2024-01-10T00:20:49.476854Z", + "iopub.status.idle": "2024-01-10T00:20:49.483425Z", + "shell.execute_reply": "2024-01-10T00:20:49.482846Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tf_cube = tf.function(cube)\n", + "tf_cube" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.486486Z", + "iopub.status.busy": "2024-01-10T00:20:49.485922Z", + "iopub.status.idle": "2024-01-10T00:20:49.528929Z", + "shell.execute_reply": "2024-01-10T00:20:49.528289Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tf_cube(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.532023Z", + "iopub.status.busy": "2024-01-10T00:20:49.531477Z", + "iopub.status.idle": "2024-01-10T00:20:49.548844Z", + "shell.execute_reply": "2024-01-10T00:20:49.548233Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tf_cube(tf.constant(2.0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When you write custom functionality with a Keras model, Keras will automatically convert your function to a TensorFlow function so typically you will not need to worry about this." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + }, + "tags": [ + "exercise_pointer" + ] + }, + "source": [ + "**Exercises:** *You can now complete Exercise 1 in the exercises associated with this lecture.*" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Reuse" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A TensorFlow function generates a new graph for each unique set of input shapes and data types. The graph is then cached for subsequent use.\n", + "\n", + "This is only the case for tensor arguments.\n", + "\n", + "If you pass numerical python values a new graph will be created for each execution. This could considerably slow down your code and may use up a lot of RAM (for the storage of many computational graphs)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we have seen when considering training, we often need to compute the gradients to train models, e.g. for gradient descent based approaches. Typically we need to compute the gradient of the cost function with respect to the model weights. \n", + "\n", + "TensorFlow supports automatical differentiation, which allows gradients to be computed automatically." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Consider the following function." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.552388Z", + "iopub.status.busy": "2024-01-10T00:20:49.551862Z", + "iopub.status.idle": "2024-01-10T00:20:49.555240Z", + "shell.execute_reply": "2024-01-10T00:20:49.554602Z" + } + }, + "outputs": [], + "source": [ + "def f(w1, w2):\n", + " return 3 * w1 ** 2 + 2 * w1 * w2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will compute gradients analytically, numerically and using TensorFlow's Autodiff functionality at the following point." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.558283Z", + "iopub.status.busy": "2024-01-10T00:20:49.557845Z", + "iopub.status.idle": "2024-01-10T00:20:49.560882Z", + "shell.execute_reply": "2024-01-10T00:20:49.560244Z" + } + }, + "outputs": [], + "source": [ + "w1, w2 = 5.0, 3.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Computing gradients analytically" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.563711Z", + "iopub.status.busy": "2024-01-10T00:20:49.563282Z", + "iopub.status.idle": "2024-01-10T00:20:49.566598Z", + "shell.execute_reply": "2024-01-10T00:20:49.565962Z" + } + }, + "outputs": [], + "source": [ + "def df_dw1(w1, w2):\n", + " return 6 * w1 + 2 * w2\n", + "def df_dw2(w1, w2):\n", + " return 2 * w1" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.569286Z", + "iopub.status.busy": "2024-01-10T00:20:49.568925Z", + "iopub.status.idle": "2024-01-10T00:20:49.572928Z", + "shell.execute_reply": "2024-01-10T00:20:49.572409Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "36.0" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_dw1(w1, w2)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.575718Z", + "iopub.status.busy": "2024-01-10T00:20:49.575285Z", + "iopub.status.idle": "2024-01-10T00:20:49.579249Z", + "shell.execute_reply": "2024-01-10T00:20:49.578727Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10.0" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_dw2(w1, w2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Computing gradients numerically\n", + "\n", + "Compute the gradient by finite differences." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.582134Z", + "iopub.status.busy": "2024-01-10T00:20:49.581584Z", + "iopub.status.idle": "2024-01-10T00:20:49.587829Z", + "shell.execute_reply": "2024-01-10T00:20:49.587195Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "36.000003007075065" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eps = 1e-6\n", + "(f(w1 + eps, w2) - f(w1, w2)) / eps" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.590728Z", + "iopub.status.busy": "2024-01-10T00:20:49.590286Z", + "iopub.status.idle": "2024-01-10T00:20:49.594499Z", + "shell.execute_reply": "2024-01-10T00:20:49.593955Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10.000000003174137" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(f(w1, w2 + eps) - f(w1, w2)) / eps" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Gradients computed are approximate.\n", + "\n", + "Required an extra function evaluation for every gradient. Computationally infeasible for many cases, e.g. large neural networks with hundreds of thousands or millions of parameters (or more!)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Computing gradients with Autodiff" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Autodiff builds derivatives of each stage of the computational graph so that gradients can be computed automatically and efficiently." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.597673Z", + "iopub.status.busy": "2024-01-10T00:20:49.597157Z", + "iopub.status.idle": "2024-01-10T00:20:49.611136Z", + "shell.execute_reply": "2024-01-10T00:20:49.610524Z" + } + }, + "outputs": [], + "source": [ + "w1, w2 = tf.Variable(5.), tf.Variable(3.)\n", + "with tf.GradientTape() as tape:\n", + " z = f(w1, w2)\n", + "\n", + "gradients = tape.gradient(z, [w1, w2])" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.614366Z", + "iopub.status.busy": "2024-01-10T00:20:49.613940Z", + "iopub.status.idle": "2024-01-10T00:20:49.619847Z", + "shell.execute_reply": "2024-01-10T00:20:49.619202Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ]" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Only requires one computation regardless of how many derivatives need to be computed and result does not suffer from any numerical approximations (only limited by machine precision arithmetic)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "#### Persistence\n", + "\n", + "Tape is erased immediately after call to `gradient` method. So will fail if you try to call it twice." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.622949Z", + "iopub.status.busy": "2024-01-10T00:20:49.622494Z", + "iopub.status.idle": "2024-01-10T00:20:49.629996Z", + "shell.execute_reply": "2024-01-10T00:20:49.629380Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A non-persistent GradientTape can only be used to compute one set of gradients (or jacobians)\n" + ] + } + ], + "source": [ + "with tf.GradientTape() as tape:\n", + " z = f(w1, w2)\n", + "\n", + "dz_dw1 = tape.gradient(z, w1)\n", + "try:\n", + " dz_dw2 = tape.gradient(z, w2)\n", + "except RuntimeError as ex:\n", + " print(ex)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Can make the tape persistent if you need to call it more than once. Then be sure to delete it once done to free resources." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.633025Z", + "iopub.status.busy": "2024-01-10T00:20:49.632451Z", + "iopub.status.idle": "2024-01-10T00:20:49.638824Z", + "shell.execute_reply": "2024-01-10T00:20:49.638206Z" + } + }, + "outputs": [], + "source": [ + "with tf.GradientTape(persistent=True) as tape:\n", + " z = f(w1, w2)\n", + "\n", + "dz_dw1 = tape.gradient(z, w1)\n", + "dz_dw2 = tape.gradient(z, w2) # works now!\n", + "del tape" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.642038Z", + "iopub.status.busy": "2024-01-10T00:20:49.641485Z", + "iopub.status.idle": "2024-01-10T00:20:49.647865Z", + "shell.execute_reply": "2024-01-10T00:20:49.647205Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " )" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dz_dw1, dz_dw2" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "#### Computing gradients wrt variables and watched tensors\n", + "\n", + "The tape only tracks variables (recall constants are immutable so it does not make sense to compute a gradient with respect to a constant).\n", + "\n", + "If you try to compute the gradient with respect to (wrt) anything other than a variable you will get a None result." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.650849Z", + "iopub.status.busy": "2024-01-10T00:20:49.650289Z", + "iopub.status.idle": "2024-01-10T00:20:49.656640Z", + "shell.execute_reply": "2024-01-10T00:20:49.655986Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[None, None]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c1, c2 = tf.constant(5.), tf.constant(3.)\n", + "with tf.GradientTape() as tape:\n", + " z = f(c1, c2)\n", + "\n", + "gradients = tape.gradient(z, [c1, c2])\n", + "gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "But you can `watch` tensors and then compute gradients with respect to watched tensors as if they were variables." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.659751Z", + "iopub.status.busy": "2024-01-10T00:20:49.659219Z", + "iopub.status.idle": "2024-01-10T00:20:49.665560Z", + "shell.execute_reply": "2024-01-10T00:20:49.664859Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ]" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "with tf.GradientTape() as tape:\n", + " tape.watch(c1)\n", + " tape.watch(c2)\n", + " z = f(c1, c2)\n", + "\n", + "gradients = tape.gradient(z, [c1, c2])\n", + "gradients" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "#### Stopping gradients propagating" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sometimes you may want to stop gradients propagating through the computational graph.\n", + "\n", + "This can be performed with `tf.stop_gradient`, which allows the function to be evaluated in the forward evaluation pass but not in the reverse gradient pass." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:20:49.668653Z", + "iopub.status.busy": "2024-01-10T00:20:49.668088Z", + "iopub.status.idle": "2024-01-10T00:20:49.677969Z", + "shell.execute_reply": "2024-01-10T00:20:49.677364Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[, None]" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def f(w1, w2):\n", + " return 3 * w1 ** 2 + tf.stop_gradient(2 * w1 * w2)\n", + "\n", + "with tf.GradientTape() as tape:\n", + " z = f(w1, w2)\n", + "\n", + "tape.gradient(z, [w1, w2])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + }, + "tags": [ + "exercise_pointer" + ] + }, + "source": [ + "**Exercises:** *You can now complete Exercise 2 in the exercises associated with this lecture.*" + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "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.8.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/week4/slides/Lecture12_IntroToKeras.ipynb b/week4/slides/Lecture12_IntroToKeras.ipynb new file mode 100644 index 0000000..ecbe872 --- /dev/null +++ b/week4/slides/Lecture12_IntroToKeras.ipynb @@ -0,0 +1,13849 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Lecture 12: Introduction to Keras" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "![](https://www.tensorflow.org/images/colab_logo_32px.png)\n", + "[Run in colab](https://colab.research.google.com/drive/1UX-aQOoLzt8q1gcGp8FQ3mM1L2qDNMA-)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:01.937442Z", + "iopub.status.busy": "2024-01-10T00:21:01.937220Z", + "iopub.status.idle": "2024-01-10T00:21:01.944877Z", + "shell.execute_reply": "2024-01-10T00:21:01.944350Z" + }, + "slideshow": { + "slide_type": "skip" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Last executed: 2024-01-10 00:21:01\n" + ] + } + ], + "source": [ + "import datetime\n", + "now = datetime.datetime.now()\n", + "print(\"Last executed: \" + now.strftime(\"%Y-%m-%d %H:%M:%S\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:01.985231Z", + "iopub.status.busy": "2024-01-10T00:21:01.984770Z", + "iopub.status.idle": "2024-01-10T00:21:04.236625Z", + "shell.execute_reply": "2024-01-10T00:21:04.235909Z" + }, + "slideshow": { + "slide_type": "skip" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-01-10 00:21:02.204927: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2024-01-10 00:21:02.255907: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2024-01-10 00:21:02.257546: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-01-10 00:21:03.094962: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Overview of Keras" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Keras is a high-level API for deep learning.\n", + "\n", + "It supports multiple back end deep learning frameworks. \n", + "\n", + "While Keras could be used with TensorFlow 1.0, as of TensorFlow 2.0 it is tightly integrated." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "-" + } + }, + "source": [ + "
\n", + "\n", + "\n", + "\n", + "[Credit: Geron]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Keras's API is similar to Facebook's [PyTorch](https://pytorch.org/) library (PyTorch and TensorFlow are the two most popular deep learning libraries). Both are very similar to the Scikit Learn API. So learning Keras will be useful if you want to transition to PyTorch.\n", + "\n", + "Plus, Keras considerably simplifies the use of TensorFlow!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Sequential API" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Keras supports a number of different APIs.\n", + "\n", + "We'll start by considering the *Sequential API*, which is the simplest and simply considers a stack of layers connected sequentially." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Loading data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll using the fashion MNIST dataset to illustrate the use of Keras.\n", + "\n", + "Keras includes support to load a number of popular datasets in `keras.datasets`.\n", + "\n", + "Let's use Keras to load fashion MNIST (note that the dataset already includes standard training and test sets)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:04.241088Z", + "iopub.status.busy": "2024-01-10T00:21:04.240457Z", + "iopub.status.idle": "2024-01-10T00:21:05.729739Z", + "shell.execute_reply": "2024-01-10T00:21:05.729032Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 8192/29515 [=======>......................] - ETA: 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "29515/29515 [==============================] - 0s 0us/step\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 8192/26421880 [..............................] - ETA: 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 466944/26421880 [..............................] - ETA: 2s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 4202496/26421880 [===>..........................] - ETA: 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "11526144/26421880 [============>.................] - ETA: 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "18325504/26421880 [===================>..........] - ETA: 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "26421880/26421880 [==============================] - 0s 0us/step\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "5148/5148 [==============================] - 0s 0us/step\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 8192/4422102 [..............................] - ETA: 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 352256/4422102 [=>............................] - ETA: 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "4422102/4422102 [==============================] - 0s 0us/step\n" + ] + } + ], + "source": [ + "fashion_mnist = keras.datasets.fashion_mnist\n", + "(X_train_full, y_train_full), (X_test, y_test) = fashion_mnist.load_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The training set contains 60,000 grayscale images, each 28x28 pixels (similar to the MNIST digit dataset):" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:05.733567Z", + "iopub.status.busy": "2024-01-10T00:21:05.732959Z", + "iopub.status.idle": "2024-01-10T00:21:05.740520Z", + "shell.execute_reply": "2024-01-10T00:21:05.739997Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(60000, 28, 28)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train_full.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Since no validation set is provided, we'll split the full training set into a validation set and a (smaller) training set.\n", + "\n", + "Let's split the full training set into a validation set and a (smaller) training set (also scale the pixel intensities from 0-255 to 0-1). " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:05.743339Z", + "iopub.status.busy": "2024-01-10T00:21:05.743122Z", + "iopub.status.idle": "2024-01-10T00:21:05.882937Z", + "shell.execute_reply": "2024-01-10T00:21:05.882199Z" + } + }, + "outputs": [], + "source": [ + "X_valid, X_train = X_train_full[:5000] / 255., X_train_full[5000:] / 255.\n", + "y_valid, y_train = y_train_full[:5000], y_train_full[5000:]\n", + "X_test = X_test / 255." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Plot individual data instance:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:05.886596Z", + "iopub.status.busy": "2024-01-10T00:21:05.886080Z", + "iopub.status.idle": "2024-01-10T00:21:06.230612Z", + "shell.execute_reply": "2024-01-10T00:21:06.229980Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "plt.imshow(X_train[0], cmap=\"binary\")\n", + "plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "The labels are the class IDs (represented as uint8), from 0 to 9:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:06.233688Z", + "iopub.status.busy": "2024-01-10T00:21:06.233227Z", + "iopub.status.idle": "2024-01-10T00:21:06.237656Z", + "shell.execute_reply": "2024-01-10T00:21:06.237128Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([4, 0, 7, ..., 3, 0, 5], dtype=uint8)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_train" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With corresponding class names:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:06.240496Z", + "iopub.status.busy": "2024-01-10T00:21:06.240042Z", + "iopub.status.idle": "2024-01-10T00:21:06.244064Z", + "shell.execute_reply": "2024-01-10T00:21:06.243454Z" + } + }, + "outputs": [], + "source": [ + "class_names = [\"T-shirt/top\", \"Trouser\", \"Pullover\", \"Dress\", \"Coat\",\n", + " \"Sandal\", \"Shirt\", \"Sneaker\", \"Bag\", \"Ankle boot\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "The validation set contains 5,000 images, and the test set contains 10,000 images:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:06.247470Z", + "iopub.status.busy": "2024-01-10T00:21:06.246948Z", + "iopub.status.idle": "2024-01-10T00:21:06.253384Z", + "shell.execute_reply": "2024-01-10T00:21:06.252778Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(5000, 28, 28)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_valid.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:06.256508Z", + "iopub.status.busy": "2024-01-10T00:21:06.256000Z", + "iopub.status.idle": "2024-01-10T00:21:06.264351Z", + "shell.execute_reply": "2024-01-10T00:21:06.261875Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(10000, 28, 28)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_test.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Plot a sample of the images in the dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:06.267722Z", + "iopub.status.busy": "2024-01-10T00:21:06.267206Z", + "iopub.status.idle": "2024-01-10T00:21:07.939486Z", + "shell.execute_reply": "2024-01-10T00:21:07.938828Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n_rows = 4\n", + "n_cols = 10\n", + "plt.figure(figsize=(n_cols * 1.2, n_rows * 1.2))\n", + "for row in range(n_rows):\n", + " for col in range(n_cols):\n", + " index = n_cols * row + col\n", + " plt.subplot(n_rows, n_cols, index + 1)\n", + " plt.imshow(X_train[index], cmap=\"binary\", interpolation=\"nearest\")\n", + " plt.axis('off')\n", + " plt.title(class_names[y_train[index]], fontsize=12)\n", + "plt.subplots_adjust(wspace=0.2, hspace=0.5)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Building the model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's build a multi-layer perceptron (MLP) with two hidden layers:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:07.943214Z", + "iopub.status.busy": "2024-01-10T00:21:07.942521Z", + "iopub.status.idle": "2024-01-10T00:21:08.021717Z", + "shell.execute_reply": "2024-01-10T00:21:08.021056Z" + } + }, + "outputs": [], + "source": [ + "model = keras.models.Sequential()\n", + "model.add(keras.layers.Flatten(input_shape=[28, 28]))\n", + "model.add(keras.layers.Dense(300, activation=\"relu\"))\n", + "model.add(keras.layers.Dense(100, activation=\"relu\"))\n", + "model.add(keras.layers.Dense(10, activation=\"softmax\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Setting up the sequential model consists of the following steps.\n", + "\n", + "1. Set up a sequential model and then we will sequentially add layers to it.\n", + "2. Flatten the 28x28 pixel image into a 1D vector. Since it is the first layer, should specify input shape.\n", + "3. Add a fully connected dense layer with 300 neurons, including a ReLU activation function.\n", + "4. Add another fully connected dense layer with 100 neurons, including a ReLU.\n", + "5. Add a final dense layer with 10 neurons so we have one per output class, and include a softmax activation function convert to class probabilities." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Alternatively, the sequential model may be specificed by a list of layers." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:08.025353Z", + "iopub.status.busy": "2024-01-10T00:21:08.024841Z", + "iopub.status.idle": "2024-01-10T00:21:08.061121Z", + "shell.execute_reply": "2024-01-10T00:21:08.060433Z" + } + }, + "outputs": [], + "source": [ + "model = keras.models.Sequential([\n", + " keras.layers.Flatten(input_shape=[28, 28]),\n", + " keras.layers.Dense(300, activation=\"relu\"),\n", + " keras.layers.Dense(100, activation=\"relu\"),\n", + " keras.layers.Dense(10, activation=\"softmax\")\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Can get a summary of the model using the `summary` method." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:08.065061Z", + "iopub.status.busy": "2024-01-10T00:21:08.064471Z", + "iopub.status.idle": "2024-01-10T00:21:08.077125Z", + "shell.execute_reply": "2024-01-10T00:21:08.076608Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_1\"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "_________________________________________________________________\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Layer (type) Output Shape Param # \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=================================================================\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " flatten_1 (Flatten) (None, 784) 0 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " dense_3 (Dense) (None, 300) 235500 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " dense_4 (Dense) (None, 100) 30100 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " dense_5 (Dense) (None, 10) 1010 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=================================================================\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total params: 266610 (1.02 MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trainable params: 266610 (1.02 MB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Non-trainable params: 0 (0.00 Byte)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Can extract list of layers from `model.layers`." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:08.082030Z", + "iopub.status.busy": "2024-01-10T00:21:08.081567Z", + "iopub.status.idle": "2024-01-10T00:21:08.087749Z", + "shell.execute_reply": "2024-01-10T00:21:08.087205Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.layers" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Compiling the model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once the model is created we still need to specify the loss function and the optimizer to use to train the model. This is set by *compiling* the model." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:08.090688Z", + "iopub.status.busy": "2024-01-10T00:21:08.090460Z", + "iopub.status.idle": "2024-01-10T00:21:08.102082Z", + "shell.execute_reply": "2024-01-10T00:21:08.101456Z" + } + }, + "outputs": [], + "source": [ + "model.compile(loss=\"sparse_categorical_crossentropy\",\n", + " optimizer=keras.optimizers.legacy.SGD(learning_rate=1e-4),\n", + " metrics=[\"accuracy\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since we have a classification problem we will use a categorical cross-entropy loss, with a stochastic gradient descent optimiser.\n", + "\n", + "We will also specify an extra metric to compute during training and evlaution, in this case the accuracy." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can find further details regarding Keras loss functions, optimisers and metrics in the Keras API.\n", + "- [Keras loss functions](https://keras.io/api/losses/)\n", + "- [Keras optimisers](https://keras.io/api/optimizers/)\n", + "- [Keras metrics](https://keras.io/api/metrics/)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Fitting the model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Call `model.fit` to fit the model, given training and validation data and number of epochs.\n", + "\n", + "The loss and extra metrics will be evaluated on the validation data at the end of each epoch." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:08.105429Z", + "iopub.status.busy": "2024-01-10T00:21:08.104968Z", + "iopub.status.idle": "2024-01-10T00:21:49.630167Z", + "shell.execute_reply": "2024-01-10T00:21:49.629473Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/1719 [..............................] - ETA: 9:17 - loss: 2.2598 - accuracy: 0.0938" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 28/1719 [..............................] - ETA: 3s - loss: 2.2947 - accuracy: 0.0960 " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 58/1719 [>.............................] - ETA: 2s - loss: 2.2928 - accuracy: 0.0916" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 88/1719 [>.............................] - ETA: 2s - loss: 2.2877 - accuracy: 0.0969" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 115/1719 [=>............................] - ETA: 2s - loss: 2.2911 - accuracy: 0.0962" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 144/1719 [=>............................] - ETA: 2s - loss: 2.2888 - accuracy: 0.0983" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 172/1719 [==>...........................] - ETA: 2s - loss: 2.2868 - accuracy: 0.1003" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 200/1719 [==>...........................] - ETA: 2s - loss: 2.2821 - accuracy: 0.1031" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 229/1719 [==>...........................] - ETA: 2s - loss: 2.2782 - accuracy: 0.1043" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 258/1719 [===>..........................] - ETA: 2s - loss: 2.2755 - accuracy: 0.1070" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 284/1719 [===>..........................] - ETA: 2s - loss: 2.2733 - accuracy: 0.1070" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 315/1719 [====>.........................] - ETA: 2s - loss: 2.2702 - accuracy: 0.1075" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 345/1719 [=====>........................] - ETA: 2s - loss: 2.2675 - accuracy: 0.1091" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 376/1719 [=====>........................] - ETA: 2s - loss: 2.2651 - accuracy: 0.1096" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 408/1719 [======>.......................] - ETA: 2s - loss: 2.2623 - accuracy: 0.1121" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 440/1719 [======>.......................] - ETA: 2s - loss: 2.2597 - accuracy: 0.1131" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 471/1719 [=======>......................] - ETA: 2s - loss: 2.2573 - accuracy: 0.1142" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 502/1719 [=======>......................] - ETA: 2s - loss: 2.2543 - accuracy: 0.1172" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 533/1719 [========>.....................] - ETA: 2s - loss: 2.2522 - accuracy: 0.1186" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 559/1719 [========>.....................] - ETA: 1s - loss: 2.2494 - accuracy: 0.1203" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 583/1719 [=========>....................] - ETA: 1s - loss: 2.2475 - accuracy: 0.1216" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 613/1719 [=========>....................] - ETA: 1s - loss: 2.2447 - accuracy: 0.1240" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 641/1719 [==========>...................] - ETA: 1s - loss: 2.2424 - accuracy: 0.1250" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 672/1719 [==========>...................] - ETA: 1s - loss: 2.2403 - accuracy: 0.1263" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 699/1719 [===========>..................] - ETA: 1s - loss: 2.2379 - accuracy: 0.1285" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 727/1719 [===========>..................] - ETA: 1s - loss: 2.2357 - accuracy: 0.1305" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 752/1719 [============>.................] - ETA: 1s - loss: 2.2335 - accuracy: 0.1324" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 783/1719 [============>.................] - ETA: 1s - loss: 2.2314 - accuracy: 0.1339" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 812/1719 [=============>................] - ETA: 1s - loss: 2.2290 - accuracy: 0.1354" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 841/1719 [=============>................] - ETA: 1s - loss: 2.2264 - accuracy: 0.1370" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 869/1719 [==============>...............] - ETA: 1s - loss: 2.2242 - accuracy: 0.1387" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 901/1719 [==============>...............] - ETA: 1s - loss: 2.2217 - accuracy: 0.1406" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 930/1719 [===============>..............] - ETA: 1s - loss: 2.2194 - accuracy: 0.1423" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 958/1719 [===============>..............] - ETA: 1s - loss: 2.2171 - accuracy: 0.1444" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 989/1719 [================>.............] - ETA: 1s - loss: 2.2145 - accuracy: 0.1466" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1016/1719 [================>.............] - ETA: 1s - loss: 2.2123 - accuracy: 0.1481" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1047/1719 [=================>............] - ETA: 1s - loss: 2.2100 - accuracy: 0.1495" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1075/1719 [=================>............] - ETA: 1s - loss: 2.2076 - accuracy: 0.1514" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1106/1719 [==================>...........] - ETA: 1s - loss: 2.2053 - accuracy: 0.1535" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1136/1719 [==================>...........] - ETA: 1s - loss: 2.2031 - accuracy: 0.1554" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1162/1719 [===================>..........] - ETA: 0s - loss: 2.2012 - accuracy: 0.1572" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1193/1719 [===================>..........] - ETA: 0s - loss: 2.1987 - accuracy: 0.1588" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1222/1719 [====================>.........] - ETA: 0s - loss: 2.1967 - accuracy: 0.1607" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1253/1719 [====================>.........] - ETA: 0s - loss: 2.1943 - accuracy: 0.1629" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1282/1719 [=====================>........] - ETA: 0s - loss: 2.1922 - accuracy: 0.1643" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1311/1719 [=====================>........] - ETA: 0s - loss: 2.1899 - accuracy: 0.1662" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1341/1719 [======================>.......] - ETA: 0s - loss: 2.1880 - accuracy: 0.1675" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1369/1719 [======================>.......] - ETA: 0s - loss: 2.1860 - accuracy: 0.1696" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1400/1719 [=======================>......] - ETA: 0s - loss: 2.1834 - accuracy: 0.1717" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1431/1719 [=======================>......] - ETA: 0s - loss: 2.1812 - accuracy: 0.1733" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1461/1719 [========================>.....] - ETA: 0s - loss: 2.1790 - accuracy: 0.1754" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1490/1719 [=========================>....] - ETA: 0s - loss: 2.1770 - accuracy: 0.1773" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1522/1719 [=========================>....] - ETA: 0s - loss: 2.1747 - accuracy: 0.1793" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1553/1719 [==========================>...] - ETA: 0s - loss: 2.1724 - accuracy: 0.1817" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1583/1719 [==========================>...] - ETA: 0s - loss: 2.1702 - accuracy: 0.1834" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1612/1719 [===========================>..] - ETA: 0s - loss: 2.1681 - accuracy: 0.1851" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1643/1719 [===========================>..] - ETA: 0s - loss: 2.1660 - accuracy: 0.1870" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1673/1719 [============================>.] - ETA: 0s - loss: 2.1637 - accuracy: 0.1890" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1704/1719 [============================>.] - ETA: 0s - loss: 2.1617 - accuracy: 0.1910" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1719/1719 [==============================] - 4s 2ms/step - loss: 2.1606 - accuracy: 0.1917 - val_loss: 2.0359 - val_accuracy: 0.3032\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 2/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/1719 [..............................] - ETA: 6s - loss: 2.0196 - accuracy: 0.2812" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 32/1719 [..............................] - ETA: 2s - loss: 2.0405 - accuracy: 0.3008" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 61/1719 [>.............................] - ETA: 2s - loss: 2.0425 - accuracy: 0.2930" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 90/1719 [>.............................] - ETA: 2s - loss: 2.0375 - accuracy: 0.2944" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 118/1719 [=>............................] - ETA: 2s - loss: 2.0366 - accuracy: 0.2953" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 148/1719 [=>............................] - ETA: 2s - loss: 2.0351 - accuracy: 0.2979" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 178/1719 [==>...........................] - ETA: 2s - loss: 2.0340 - accuracy: 0.3002" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 210/1719 [==>...........................] - ETA: 2s - loss: 2.0323 - accuracy: 0.2984" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 236/1719 [===>..........................] - ETA: 2s - loss: 2.0312 - accuracy: 0.2995" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 264/1719 [===>..........................] - ETA: 2s - loss: 2.0296 - accuracy: 0.3005" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 295/1719 [====>.........................] - ETA: 2s - loss: 2.0270 - accuracy: 0.3036" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 321/1719 [====>.........................] - ETA: 2s - loss: 2.0263 - accuracy: 0.3039" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 346/1719 [=====>........................] - ETA: 2s - loss: 2.0245 - accuracy: 0.3076" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 376/1719 [=====>........................] - ETA: 2s - loss: 2.0222 - accuracy: 0.3112" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 406/1719 [======>.......................] - ETA: 2s - loss: 2.0197 - accuracy: 0.3142" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 433/1719 [======>.......................] - ETA: 2s - loss: 2.0184 - accuracy: 0.3153" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 462/1719 [=======>......................] - ETA: 2s - loss: 2.0158 - accuracy: 0.3183" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 491/1719 [=======>......................] - ETA: 2s - loss: 2.0141 - accuracy: 0.3202" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 524/1719 [========>.....................] - ETA: 2s - loss: 2.0117 - accuracy: 0.3236" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 552/1719 [========>.....................] - ETA: 2s - loss: 2.0101 - accuracy: 0.3247" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 579/1719 [=========>....................] - ETA: 2s - loss: 2.0081 - accuracy: 0.3267" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 609/1719 [=========>....................] - ETA: 1s - loss: 2.0068 - accuracy: 0.3276" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 636/1719 [==========>...................] - ETA: 1s - loss: 2.0053 - accuracy: 0.3292" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 664/1719 [==========>...................] - ETA: 1s - loss: 2.0027 - accuracy: 0.3330" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 693/1719 [===========>..................] - ETA: 1s - loss: 2.0012 - accuracy: 0.3347" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 723/1719 [===========>..................] - ETA: 1s - loss: 1.9994 - accuracy: 0.3364" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 752/1719 [============>.................] - ETA: 1s - loss: 1.9975 - accuracy: 0.3382" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 781/1719 [============>.................] - ETA: 1s - loss: 1.9952 - accuracy: 0.3409" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 811/1719 [=============>................] - ETA: 1s - loss: 1.9933 - accuracy: 0.3434" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 838/1719 [=============>................] - ETA: 1s - loss: 1.9916 - accuracy: 0.3457" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 864/1719 [==============>...............] - ETA: 1s - loss: 1.9898 - accuracy: 0.3477" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 895/1719 [==============>...............] - ETA: 1s - loss: 1.9880 - accuracy: 0.3493" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 923/1719 [===============>..............] - ETA: 1s - loss: 1.9863 - accuracy: 0.3509" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 954/1719 [===============>..............] - ETA: 1s - loss: 1.9848 - accuracy: 0.3523" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 984/1719 [================>.............] - ETA: 1s - loss: 1.9827 - accuracy: 0.3541" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1015/1719 [================>.............] - ETA: 1s - loss: 1.9808 - accuracy: 0.3560" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1043/1719 [=================>............] - ETA: 1s - loss: 1.9788 - accuracy: 0.3577" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1071/1719 [=================>............] - ETA: 1s - loss: 1.9772 - accuracy: 0.3597" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1098/1719 [==================>...........] - ETA: 1s - loss: 1.9756 - accuracy: 0.3612" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1127/1719 [==================>...........] - ETA: 1s - loss: 1.9739 - accuracy: 0.3627" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1155/1719 [===================>..........] - ETA: 0s - loss: 1.9722 - accuracy: 0.3642" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1186/1719 [===================>..........] - ETA: 0s - loss: 1.9702 - accuracy: 0.3666" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1215/1719 [====================>.........] - ETA: 0s - loss: 1.9688 - accuracy: 0.3679" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1246/1719 [====================>.........] - ETA: 0s - loss: 1.9671 - accuracy: 0.3691" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1275/1719 [=====================>........] - ETA: 0s - loss: 1.9653 - accuracy: 0.3712" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1305/1719 [=====================>........] - ETA: 0s - loss: 1.9637 - accuracy: 0.3724" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1333/1719 [======================>.......] - ETA: 0s - loss: 1.9615 - accuracy: 0.3748" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1358/1719 [======================>.......] - ETA: 0s - loss: 1.9601 - accuracy: 0.3767" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1387/1719 [=======================>......] - ETA: 0s - loss: 1.9581 - accuracy: 0.3789" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1417/1719 [=======================>......] - ETA: 0s - loss: 1.9566 - accuracy: 0.3801" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1447/1719 [========================>.....] - ETA: 0s - loss: 1.9548 - accuracy: 0.3822" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1477/1719 [========================>.....] - ETA: 0s - loss: 1.9531 - accuracy: 0.3842" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1506/1719 [=========================>....] - ETA: 0s - loss: 1.9513 - accuracy: 0.3861" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1536/1719 [=========================>....] - ETA: 0s - loss: 1.9497 - accuracy: 0.3872" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1567/1719 [==========================>...] - ETA: 0s - loss: 1.9482 - accuracy: 0.3883" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1593/1719 [==========================>...] - ETA: 0s - loss: 1.9467 - accuracy: 0.3898" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1625/1719 [===========================>..] - ETA: 0s - loss: 1.9449 - accuracy: 0.3914" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1651/1719 [===========================>..] - ETA: 0s - loss: 1.9433 - accuracy: 0.3927" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1682/1719 [============================>.] - ETA: 0s - loss: 1.9417 - accuracy: 0.3943" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1712/1719 [============================>.] - ETA: 0s - loss: 1.9401 - accuracy: 0.3956" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1719/1719 [==============================] - 3s 2ms/step - loss: 1.9397 - accuracy: 0.3959 - val_loss: 1.8297 - val_accuracy: 0.4970\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 3/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/1719 [..............................] - ETA: 4s - loss: 1.8490 - accuracy: 0.5000" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 29/1719 [..............................] - ETA: 3s - loss: 1.8330 - accuracy: 0.4784" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 57/1719 [..............................] - ETA: 3s - loss: 1.8258 - accuracy: 0.4940" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 85/1719 [>.............................] - ETA: 2s - loss: 1.8373 - accuracy: 0.4820" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 114/1719 [>.............................] - ETA: 2s - loss: 1.8298 - accuracy: 0.4888" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 146/1719 [=>............................] - ETA: 2s - loss: 1.8270 - accuracy: 0.4925" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 178/1719 [==>...........................] - ETA: 2s - loss: 1.8263 - accuracy: 0.4942" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 209/1719 [==>...........................] - ETA: 2s - loss: 1.8263 - accuracy: 0.4951" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 240/1719 [===>..........................] - ETA: 2s - loss: 1.8244 - accuracy: 0.4939" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 269/1719 [===>..........................] - ETA: 2s - loss: 1.8245 - accuracy: 0.4935" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 298/1719 [====>.........................] - ETA: 2s - loss: 1.8228 - accuracy: 0.4936" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 330/1719 [====>.........................] - ETA: 2s - loss: 1.8203 - accuracy: 0.4956" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 361/1719 [=====>........................] - ETA: 2s - loss: 1.8192 - accuracy: 0.4958" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 391/1719 [=====>........................] - ETA: 2s - loss: 1.8177 - accuracy: 0.4964" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 421/1719 [======>.......................] - ETA: 2s - loss: 1.8153 - accuracy: 0.4970" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 450/1719 [======>.......................] - ETA: 2s - loss: 1.8138 - accuracy: 0.4976" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 480/1719 [=======>......................] - ETA: 2s - loss: 1.8127 - accuracy: 0.4982" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 507/1719 [=======>......................] - ETA: 2s - loss: 1.8110 - accuracy: 0.4988" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 536/1719 [========>.....................] - ETA: 2s - loss: 1.8090 - accuracy: 0.5007" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 568/1719 [========>.....................] - ETA: 1s - loss: 1.8071 - accuracy: 0.5024" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 601/1719 [=========>....................] - ETA: 1s - loss: 1.8055 - accuracy: 0.5030" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 630/1719 [=========>....................] - ETA: 1s - loss: 1.8031 - accuracy: 0.5051" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 663/1719 [==========>...................] - ETA: 1s - loss: 1.8014 - accuracy: 0.5059" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 694/1719 [===========>..................] - ETA: 1s - loss: 1.7996 - accuracy: 0.5072" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 725/1719 [===========>..................] - ETA: 1s - loss: 1.7975 - accuracy: 0.5084" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 755/1719 [============>.................] - ETA: 1s - loss: 1.7959 - accuracy: 0.5101" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 786/1719 [============>.................] - ETA: 1s - loss: 1.7942 - accuracy: 0.5113" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 816/1719 [=============>................] - ETA: 1s - loss: 1.7929 - accuracy: 0.5121" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 843/1719 [=============>................] - ETA: 1s - loss: 1.7921 - accuracy: 0.5126" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 873/1719 [==============>...............] - ETA: 1s - loss: 1.7909 - accuracy: 0.5134" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 905/1719 [==============>...............] - ETA: 1s - loss: 1.7889 - accuracy: 0.5150" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 936/1719 [===============>..............] - ETA: 1s - loss: 1.7872 - accuracy: 0.5162" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 966/1719 [===============>..............] - ETA: 1s - loss: 1.7858 - accuracy: 0.5165" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 992/1719 [================>.............] - ETA: 1s - loss: 1.7847 - accuracy: 0.5170" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1020/1719 [================>.............] - ETA: 1s - loss: 1.7824 - accuracy: 0.5183" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1050/1719 [=================>............] - ETA: 1s - loss: 1.7809 - accuracy: 0.5191" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1078/1719 [=================>............] - ETA: 1s - loss: 1.7794 - accuracy: 0.5204" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1110/1719 [==================>...........] - ETA: 1s - loss: 1.7775 - accuracy: 0.5216" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1140/1719 [==================>...........] - ETA: 0s - loss: 1.7763 - accuracy: 0.5225" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1171/1719 [===================>..........] - ETA: 0s - loss: 1.7749 - accuracy: 0.5230" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1199/1719 [===================>..........] - ETA: 0s - loss: 1.7735 - accuracy: 0.5239" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1227/1719 [====================>.........] - ETA: 0s - loss: 1.7722 - accuracy: 0.5239" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1253/1719 [====================>.........] - ETA: 0s - loss: 1.7709 - accuracy: 0.5247" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1279/1719 [=====================>........] - ETA: 0s - loss: 1.7690 - accuracy: 0.5260" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1310/1719 [=====================>........] - ETA: 0s - loss: 1.7676 - accuracy: 0.5265" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1340/1719 [======================>.......] - ETA: 0s - loss: 1.7661 - accuracy: 0.5279" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1371/1719 [======================>.......] - ETA: 0s - loss: 1.7649 - accuracy: 0.5290" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1402/1719 [=======================>......] - ETA: 0s - loss: 1.7634 - accuracy: 0.5297" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1432/1719 [=======================>......] - ETA: 0s - loss: 1.7622 - accuracy: 0.5307" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1462/1719 [========================>.....] - ETA: 0s - loss: 1.7608 - accuracy: 0.5311" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1489/1719 [========================>.....] - ETA: 0s - loss: 1.7595 - accuracy: 0.5317" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1519/1719 [=========================>....] - ETA: 0s - loss: 1.7578 - accuracy: 0.5325" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1545/1719 [=========================>....] - ETA: 0s - loss: 1.7562 - accuracy: 0.5332" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1576/1719 [==========================>...] - ETA: 0s - loss: 1.7547 - accuracy: 0.5337" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1607/1719 [===========================>..] - ETA: 0s - loss: 1.7530 - accuracy: 0.5348" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1635/1719 [===========================>..] - ETA: 0s - loss: 1.7513 - accuracy: 0.5357" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1665/1719 [============================>.] - ETA: 0s - loss: 1.7496 - accuracy: 0.5361" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1695/1719 [============================>.] - ETA: 0s - loss: 1.7480 - accuracy: 0.5372" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1719/1719 [==============================] - 3s 2ms/step - loss: 1.7468 - accuracy: 0.5376 - val_loss: 1.6438 - val_accuracy: 0.5928\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 4/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/1719 [..............................] - ETA: 5s - loss: 1.5378 - accuracy: 0.6250" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 30/1719 [..............................] - ETA: 2s - loss: 1.6332 - accuracy: 0.5990" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 58/1719 [>.............................] - ETA: 2s - loss: 1.6395 - accuracy: 0.5889" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 87/1719 [>.............................] - ETA: 2s - loss: 1.6387 - accuracy: 0.5938" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 118/1719 [=>............................] - ETA: 2s - loss: 1.6419 - accuracy: 0.5821" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 144/1719 [=>............................] - ETA: 2s - loss: 1.6431 - accuracy: 0.5836" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 176/1719 [==>...........................] - ETA: 2s - loss: 1.6406 - accuracy: 0.5840" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 208/1719 [==>...........................] - ETA: 2s - loss: 1.6378 - accuracy: 0.5868" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 239/1719 [===>..........................] - ETA: 2s - loss: 1.6374 - accuracy: 0.5901" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 269/1719 [===>..........................] - ETA: 2s - loss: 1.6381 - accuracy: 0.5882" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 298/1719 [====>.........................] - ETA: 2s - loss: 1.6374 - accuracy: 0.5884" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 325/1719 [====>.........................] - ETA: 2s - loss: 1.6359 - accuracy: 0.5894" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 355/1719 [=====>........................] - ETA: 2s - loss: 1.6370 - accuracy: 0.5869" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 382/1719 [=====>........................] - ETA: 2s - loss: 1.6369 - accuracy: 0.5858" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 414/1719 [======>.......................] - ETA: 2s - loss: 1.6367 - accuracy: 0.5866" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 443/1719 [======>.......................] - ETA: 2s - loss: 1.6364 - accuracy: 0.5856" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 471/1719 [=======>......................] - ETA: 2s - loss: 1.6355 - accuracy: 0.5849" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 498/1719 [=======>......................] - ETA: 2s - loss: 1.6344 - accuracy: 0.5841" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 528/1719 [========>.....................] - ETA: 2s - loss: 1.6328 - accuracy: 0.5851" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 557/1719 [========>.....................] - ETA: 2s - loss: 1.6317 - accuracy: 0.5842" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 587/1719 [=========>....................] - ETA: 1s - loss: 1.6302 - accuracy: 0.5833" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 616/1719 [=========>....................] - ETA: 1s - loss: 1.6284 - accuracy: 0.5849" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 647/1719 [==========>...................] - ETA: 1s - loss: 1.6257 - accuracy: 0.5869" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 674/1719 [==========>...................] - ETA: 1s - loss: 1.6248 - accuracy: 0.5872" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 704/1719 [===========>..................] - ETA: 1s - loss: 1.6230 - accuracy: 0.5874" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 722/1719 [===========>..................] - ETA: 1s - loss: 1.6218 - accuracy: 0.5880" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 752/1719 [============>.................] - ETA: 1s - loss: 1.6193 - accuracy: 0.5897" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 782/1719 [============>.................] - ETA: 1s - loss: 1.6182 - accuracy: 0.5899" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 814/1719 [=============>................] - ETA: 1s - loss: 1.6166 - accuracy: 0.5911" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 845/1719 [=============>................] - ETA: 1s - loss: 1.6155 - accuracy: 0.5913" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 874/1719 [==============>...............] - ETA: 1s - loss: 1.6140 - accuracy: 0.5921" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 902/1719 [==============>...............] - ETA: 1s - loss: 1.6132 - accuracy: 0.5914" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 932/1719 [===============>..............] - ETA: 1s - loss: 1.6121 - accuracy: 0.5915" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 960/1719 [===============>..............] - ETA: 1s - loss: 1.6112 - accuracy: 0.5919" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 992/1719 [================>.............] - ETA: 1s - loss: 1.6091 - accuracy: 0.5933" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1020/1719 [================>.............] - ETA: 1s - loss: 1.6074 - accuracy: 0.5936" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1051/1719 [=================>............] - ETA: 1s - loss: 1.6061 - accuracy: 0.5938" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1079/1719 [=================>............] - ETA: 1s - loss: 1.6044 - accuracy: 0.5945" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1106/1719 [==================>...........] - ETA: 1s - loss: 1.6031 - accuracy: 0.5949" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1135/1719 [==================>...........] - ETA: 1s - loss: 1.6019 - accuracy: 0.5955" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1167/1719 [===================>..........] - ETA: 0s - loss: 1.6007 - accuracy: 0.5960" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1199/1719 [===================>..........] - ETA: 0s - loss: 1.5989 - accuracy: 0.5969" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1230/1719 [====================>.........] - ETA: 0s - loss: 1.5973 - accuracy: 0.5970" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1261/1719 [=====================>........] - ETA: 0s - loss: 1.5958 - accuracy: 0.5973" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1291/1719 [=====================>........] - ETA: 0s - loss: 1.5945 - accuracy: 0.5977" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1322/1719 [======================>.......] - ETA: 0s - loss: 1.5932 - accuracy: 0.5980" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1352/1719 [======================>.......] - ETA: 0s - loss: 1.5918 - accuracy: 0.5985" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1380/1719 [=======================>......] - ETA: 0s - loss: 1.5912 - accuracy: 0.5982" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1410/1719 [=======================>......] - ETA: 0s - loss: 1.5901 - accuracy: 0.5982" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1439/1719 [========================>.....] - ETA: 0s - loss: 1.5893 - accuracy: 0.5984" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1466/1719 [========================>.....] - ETA: 0s - loss: 1.5884 - accuracy: 0.5984" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1497/1719 [=========================>....] - ETA: 0s - loss: 1.5868 - accuracy: 0.5989" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1527/1719 [=========================>....] - ETA: 0s - loss: 1.5852 - accuracy: 0.5993" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1555/1719 [==========================>...] - ETA: 0s - loss: 1.5843 - accuracy: 0.5995" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1588/1719 [==========================>...] - ETA: 0s - loss: 1.5826 - accuracy: 0.6002" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1615/1719 [===========================>..] - ETA: 0s - loss: 1.5810 - accuracy: 0.6009" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1639/1719 [===========================>..] - ETA: 0s - loss: 1.5802 - accuracy: 0.6006" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1669/1719 [============================>.] - ETA: 0s - loss: 1.5785 - accuracy: 0.6012" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1699/1719 [============================>.] - ETA: 0s - loss: 1.5769 - accuracy: 0.6016" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1719/1719 [==============================] - 3s 2ms/step - loss: 1.5761 - accuracy: 0.6021 - val_loss: 1.4832 - val_accuracy: 0.6296\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 5/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/1719 [..............................] - ETA: 4s - loss: 1.4024 - accuracy: 0.7500" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 31/1719 [..............................] - ETA: 2s - loss: 1.4930 - accuracy: 0.6502" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 63/1719 [>.............................] - ETA: 2s - loss: 1.4978 - accuracy: 0.6369" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 92/1719 [>.............................] - ETA: 2s - loss: 1.5071 - accuracy: 0.6264" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 121/1719 [=>............................] - ETA: 2s - loss: 1.4962 - accuracy: 0.6340" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 150/1719 [=>............................] - ETA: 2s - loss: 1.4928 - accuracy: 0.6333" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 181/1719 [==>...........................] - ETA: 2s - loss: 1.4940 - accuracy: 0.6286" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 212/1719 [==>...........................] - ETA: 2s - loss: 1.4936 - accuracy: 0.6265" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 242/1719 [===>..........................] - ETA: 2s - loss: 1.4897 - accuracy: 0.6281" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 269/1719 [===>..........................] - ETA: 2s - loss: 1.4871 - accuracy: 0.6287" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 298/1719 [====>.........................] - ETA: 2s - loss: 1.4838 - accuracy: 0.6307" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 327/1719 [====>.........................] - ETA: 2s - loss: 1.4806 - accuracy: 0.6324" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 357/1719 [=====>........................] - ETA: 2s - loss: 1.4813 - accuracy: 0.6308" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 385/1719 [=====>........................] - ETA: 2s - loss: 1.4802 - accuracy: 0.6295" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 415/1719 [======>.......................] - ETA: 2s - loss: 1.4779 - accuracy: 0.6304" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 441/1719 [======>.......................] - ETA: 2s - loss: 1.4770 - accuracy: 0.6305" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 472/1719 [=======>......................] - ETA: 2s - loss: 1.4766 - accuracy: 0.6290" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 503/1719 [=======>......................] - ETA: 2s - loss: 1.4767 - accuracy: 0.6287" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 534/1719 [========>.....................] - ETA: 2s - loss: 1.4750 - accuracy: 0.6293" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 564/1719 [========>.....................] - ETA: 1s - loss: 1.4746 - accuracy: 0.6289" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 593/1719 [=========>....................] - ETA: 1s - loss: 1.4748 - accuracy: 0.6278" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 624/1719 [=========>....................] - ETA: 1s - loss: 1.4739 - accuracy: 0.6272" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 651/1719 [==========>...................] - ETA: 1s - loss: 1.4724 - accuracy: 0.6284" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 679/1719 [==========>...................] - ETA: 1s - loss: 1.4702 - accuracy: 0.6290" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 709/1719 [===========>..................] - ETA: 1s - loss: 1.4691 - accuracy: 0.6289" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 739/1719 [===========>..................] - ETA: 1s - loss: 1.4672 - accuracy: 0.6300" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 767/1719 [============>.................] - ETA: 1s - loss: 1.4666 - accuracy: 0.6299" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 793/1719 [============>.................] - ETA: 1s - loss: 1.4651 - accuracy: 0.6304" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 822/1719 [=============>................] - ETA: 1s - loss: 1.4629 - accuracy: 0.6311" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 853/1719 [=============>................] - ETA: 1s - loss: 1.4612 - accuracy: 0.6314" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 880/1719 [==============>...............] - ETA: 1s - loss: 1.4611 - accuracy: 0.6313" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 908/1719 [==============>...............] - ETA: 1s - loss: 1.4606 - accuracy: 0.6314" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 938/1719 [===============>..............] - ETA: 1s - loss: 1.4594 - accuracy: 0.6313" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 967/1719 [===============>..............] - ETA: 1s - loss: 1.4587 - accuracy: 0.6306" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 995/1719 [================>.............] - ETA: 1s - loss: 1.4574 - accuracy: 0.6304" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1026/1719 [================>.............] - ETA: 1s - loss: 1.4562 - accuracy: 0.6310" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1055/1719 [=================>............] - ETA: 1s - loss: 1.4549 - accuracy: 0.6313" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1083/1719 [=================>............] - ETA: 1s - loss: 1.4540 - accuracy: 0.6313" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1114/1719 [==================>...........] - ETA: 1s - loss: 1.4531 - accuracy: 0.6313" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1143/1719 [==================>...........] - ETA: 0s - loss: 1.4523 - accuracy: 0.6313" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1176/1719 [===================>..........] - ETA: 0s - loss: 1.4504 - accuracy: 0.6324" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1205/1719 [====================>.........] - ETA: 0s - loss: 1.4502 - accuracy: 0.6321" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1232/1719 [====================>.........] - ETA: 0s - loss: 1.4492 - accuracy: 0.6327" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1261/1719 [=====================>........] - ETA: 0s - loss: 1.4476 - accuracy: 0.6328" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1292/1719 [=====================>........] - ETA: 0s - loss: 1.4464 - accuracy: 0.6330" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1319/1719 [======================>.......] - ETA: 0s - loss: 1.4451 - accuracy: 0.6331" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1348/1719 [======================>.......] - ETA: 0s - loss: 1.4440 - accuracy: 0.6334" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1373/1719 [======================>.......] - ETA: 0s - loss: 1.4431 - accuracy: 0.6335" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1398/1719 [=======================>......] - ETA: 0s - loss: 1.4421 - accuracy: 0.6335" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1428/1719 [=======================>......] - ETA: 0s - loss: 1.4413 - accuracy: 0.6335" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1458/1719 [========================>.....] - ETA: 0s - loss: 1.4401 - accuracy: 0.6338" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1485/1719 [========================>.....] - ETA: 0s - loss: 1.4386 - accuracy: 0.6339" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1511/1719 [=========================>....] - ETA: 0s - loss: 1.4371 - accuracy: 0.6344" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1541/1719 [=========================>....] - ETA: 0s - loss: 1.4359 - accuracy: 0.6343" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1569/1719 [==========================>...] - ETA: 0s - loss: 1.4348 - accuracy: 0.6346" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1596/1719 [==========================>...] - ETA: 0s - loss: 1.4335 - accuracy: 0.6347" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1628/1719 [===========================>..] - ETA: 0s - loss: 1.4326 - accuracy: 0.6345" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1658/1719 [===========================>..] - ETA: 0s - loss: 1.4318 - accuracy: 0.6348" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1688/1719 [============================>.] - ETA: 0s - loss: 1.4307 - accuracy: 0.6346" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1716/1719 [============================>.] - ETA: 0s - loss: 1.4300 - accuracy: 0.6341" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1719/1719 [==============================] - 3s 2ms/step - loss: 1.4300 - accuracy: 0.6340 - val_loss: 1.3473 - val_accuracy: 0.6592\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 6/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/1719 [..............................] - ETA: 4s - loss: 1.4488 - accuracy: 0.5312" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 29/1719 [..............................] - ETA: 3s - loss: 1.3671 - accuracy: 0.6476" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 60/1719 [>.............................] - ETA: 2s - loss: 1.3590 - accuracy: 0.6542" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 90/1719 [>.............................] - ETA: 2s - loss: 1.3667 - accuracy: 0.6493" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 122/1719 [=>............................] - ETA: 2s - loss: 1.3579 - accuracy: 0.6481" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 149/1719 [=>............................] - ETA: 2s - loss: 1.3523 - accuracy: 0.6514" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 177/1719 [==>...........................] - ETA: 2s - loss: 1.3544 - accuracy: 0.6480" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 206/1719 [==>...........................] - ETA: 2s - loss: 1.3523 - accuracy: 0.6481" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 231/1719 [===>..........................] - ETA: 2s - loss: 1.3494 - accuracy: 0.6473" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 262/1719 [===>..........................] - ETA: 2s - loss: 1.3503 - accuracy: 0.6467" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 290/1719 [====>.........................] - ETA: 2s - loss: 1.3519 - accuracy: 0.6445" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 319/1719 [====>.........................] - ETA: 2s - loss: 1.3529 - accuracy: 0.6432" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 349/1719 [=====>........................] - ETA: 2s - loss: 1.3531 - accuracy: 0.6418" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 376/1719 [=====>........................] - ETA: 2s - loss: 1.3544 - accuracy: 0.6397" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 406/1719 [======>.......................] - ETA: 2s - loss: 1.3529 - accuracy: 0.6398" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 434/1719 [======>.......................] - ETA: 2s - loss: 1.3514 - accuracy: 0.6404" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 464/1719 [=======>......................] - ETA: 2s - loss: 1.3498 - accuracy: 0.6416" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 493/1719 [=======>......................] - ETA: 2s - loss: 1.3491 - accuracy: 0.6419" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 522/1719 [========>.....................] - ETA: 2s - loss: 1.3476 - accuracy: 0.6428" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 549/1719 [========>.....................] - ETA: 2s - loss: 1.3475 - accuracy: 0.6427" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 580/1719 [=========>....................] - ETA: 1s - loss: 1.3453 - accuracy: 0.6439" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 609/1719 [=========>....................] - ETA: 1s - loss: 1.3443 - accuracy: 0.6447" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 636/1719 [==========>...................] - ETA: 1s - loss: 1.3434 - accuracy: 0.6449" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 668/1719 [==========>...................] - ETA: 1s - loss: 1.3432 - accuracy: 0.6437" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 697/1719 [===========>..................] - ETA: 1s - loss: 1.3421 - accuracy: 0.6437" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 727/1719 [===========>..................] - ETA: 1s - loss: 1.3425 - accuracy: 0.6435" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 757/1719 [============>.................] - ETA: 1s - loss: 1.3423 - accuracy: 0.6428" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 788/1719 [============>.................] - ETA: 1s - loss: 1.3416 - accuracy: 0.6433" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 820/1719 [=============>................] - ETA: 1s - loss: 1.3405 - accuracy: 0.6439" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 846/1719 [=============>................] - ETA: 1s - loss: 1.3388 - accuracy: 0.6456" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 878/1719 [==============>...............] - ETA: 1s - loss: 1.3374 - accuracy: 0.6462" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 910/1719 [==============>...............] - ETA: 1s - loss: 1.3361 - accuracy: 0.6464" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 938/1719 [===============>..............] - ETA: 1s - loss: 1.3340 - accuracy: 0.6477" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 965/1719 [===============>..............] - ETA: 1s - loss: 1.3328 - accuracy: 0.6484" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 995/1719 [================>.............] - ETA: 1s - loss: 1.3309 - accuracy: 0.6497" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1025/1719 [================>.............] - ETA: 1s - loss: 1.3295 - accuracy: 0.6505" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1054/1719 [=================>............] - ETA: 1s - loss: 1.3290 - accuracy: 0.6501" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1084/1719 [=================>............] - ETA: 1s - loss: 1.3280 - accuracy: 0.6505" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1113/1719 [==================>...........] - ETA: 1s - loss: 1.3272 - accuracy: 0.6506" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1142/1719 [==================>...........] - ETA: 1s - loss: 1.3263 - accuracy: 0.6507" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1170/1719 [===================>..........] - ETA: 0s - loss: 1.3256 - accuracy: 0.6509" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1197/1719 [===================>..........] - ETA: 0s - loss: 1.3237 - accuracy: 0.6516" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1225/1719 [====================>.........] - ETA: 0s - loss: 1.3226 - accuracy: 0.6517" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1254/1719 [====================>.........] - ETA: 0s - loss: 1.3210 - accuracy: 0.6517" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1284/1719 [=====================>........] - ETA: 0s - loss: 1.3202 - accuracy: 0.6517" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1312/1719 [=====================>........] - ETA: 0s - loss: 1.3187 - accuracy: 0.6523" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1339/1719 [======================>.......] - ETA: 0s - loss: 1.3175 - accuracy: 0.6523" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1371/1719 [======================>.......] - ETA: 0s - loss: 1.3169 - accuracy: 0.6517" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1399/1719 [=======================>......] - ETA: 0s - loss: 1.3160 - accuracy: 0.6520" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1429/1719 [=======================>......] - ETA: 0s - loss: 1.3152 - accuracy: 0.6517" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1456/1719 [========================>.....] - ETA: 0s - loss: 1.3145 - accuracy: 0.6522" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1483/1719 [========================>.....] - ETA: 0s - loss: 1.3132 - accuracy: 0.6529" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1511/1719 [=========================>....] - ETA: 0s - loss: 1.3128 - accuracy: 0.6528" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1539/1719 [=========================>....] - ETA: 0s - loss: 1.3125 - accuracy: 0.6521" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1570/1719 [==========================>...] - ETA: 0s - loss: 1.3115 - accuracy: 0.6524" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1601/1719 [==========================>...] - ETA: 0s - loss: 1.3105 - accuracy: 0.6525" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1631/1719 [===========================>..] - ETA: 0s - loss: 1.3098 - accuracy: 0.6523" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1657/1719 [===========================>..] - ETA: 0s - loss: 1.3093 - accuracy: 0.6523" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1685/1719 [============================>.] - ETA: 0s - loss: 1.3081 - accuracy: 0.6525" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1712/1719 [============================>.] - ETA: 0s - loss: 1.3070 - accuracy: 0.6530" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1719/1719 [==============================] - 3s 2ms/step - loss: 1.3068 - accuracy: 0.6530 - val_loss: 1.2338 - val_accuracy: 0.6708\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 7/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/1719 [..............................] - ETA: 4s - loss: 1.1439 - accuracy: 0.5938" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 32/1719 [..............................] - ETA: 2s - loss: 1.2453 - accuracy: 0.6465" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 57/1719 [..............................] - ETA: 3s - loss: 1.2559 - accuracy: 0.6436" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 89/1719 [>.............................] - ETA: 2s - loss: 1.2512 - accuracy: 0.6478" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 118/1719 [=>............................] - ETA: 2s - loss: 1.2474 - accuracy: 0.6475" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 145/1719 [=>............................] - ETA: 2s - loss: 1.2541 - accuracy: 0.6459" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 175/1719 [==>...........................] - ETA: 2s - loss: 1.2484 - accuracy: 0.6529" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 207/1719 [==>...........................] - ETA: 2s - loss: 1.2531 - accuracy: 0.6495" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 236/1719 [===>..........................] - ETA: 2s - loss: 1.2508 - accuracy: 0.6524" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 262/1719 [===>..........................] - ETA: 2s - loss: 1.2551 - accuracy: 0.6504" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 293/1719 [====>.........................] - ETA: 2s - loss: 1.2529 - accuracy: 0.6519" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 325/1719 [====>.........................] - ETA: 2s - loss: 1.2526 - accuracy: 0.6513" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 355/1719 [=====>........................] - ETA: 2s - loss: 1.2505 - accuracy: 0.6528" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 387/1719 [=====>........................] - ETA: 2s - loss: 1.2481 - accuracy: 0.6534" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 417/1719 [======>.......................] - ETA: 2s - loss: 1.2475 - accuracy: 0.6532" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 444/1719 [======>.......................] - ETA: 2s - loss: 1.2473 - accuracy: 0.6532" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 471/1719 [=======>......................] - ETA: 2s - loss: 1.2447 - accuracy: 0.6544" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 501/1719 [=======>......................] - ETA: 2s - loss: 1.2423 - accuracy: 0.6555" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 529/1719 [========>.....................] - ETA: 2s - loss: 1.2402 - accuracy: 0.6568" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 561/1719 [========>.....................] - ETA: 2s - loss: 1.2378 - accuracy: 0.6594" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 587/1719 [=========>....................] - ETA: 1s - loss: 1.2357 - accuracy: 0.6601" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 619/1719 [=========>....................] - ETA: 1s - loss: 1.2339 - accuracy: 0.6614" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 643/1719 [==========>...................] - ETA: 1s - loss: 1.2344 - accuracy: 0.6607" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 673/1719 [==========>...................] - ETA: 1s - loss: 1.2339 - accuracy: 0.6608" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 704/1719 [===========>..................] - ETA: 1s - loss: 1.2332 - accuracy: 0.6604" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 734/1719 [===========>..................] - ETA: 1s - loss: 1.2320 - accuracy: 0.6606" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 760/1719 [============>.................] - ETA: 1s - loss: 1.2306 - accuracy: 0.6616" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 786/1719 [============>.................] - ETA: 1s - loss: 1.2293 - accuracy: 0.6626" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 816/1719 [=============>................] - ETA: 1s - loss: 1.2280 - accuracy: 0.6627" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 846/1719 [=============>................] - ETA: 1s - loss: 1.2266 - accuracy: 0.6626" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 873/1719 [==============>...............] - ETA: 1s - loss: 1.2262 - accuracy: 0.6623" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 904/1719 [==============>...............] - ETA: 1s - loss: 1.2251 - accuracy: 0.6630" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 931/1719 [===============>..............] - ETA: 1s - loss: 1.2242 - accuracy: 0.6634" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 957/1719 [===============>..............] - ETA: 1s - loss: 1.2227 - accuracy: 0.6642" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 987/1719 [================>.............] - ETA: 1s - loss: 1.2221 - accuracy: 0.6646" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1017/1719 [================>.............] - ETA: 1s - loss: 1.2212 - accuracy: 0.6646" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1043/1719 [=================>............] - ETA: 1s - loss: 1.2205 - accuracy: 0.6645" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1072/1719 [=================>............] - ETA: 1s - loss: 1.2205 - accuracy: 0.6641" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1100/1719 [==================>...........] - ETA: 1s - loss: 1.2200 - accuracy: 0.6639" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1125/1719 [==================>...........] - ETA: 1s - loss: 1.2193 - accuracy: 0.6640" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1154/1719 [===================>..........] - ETA: 0s - loss: 1.2188 - accuracy: 0.6646" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1181/1719 [===================>..........] - ETA: 0s - loss: 1.2178 - accuracy: 0.6650" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1206/1719 [====================>.........] - ETA: 0s - loss: 1.2178 - accuracy: 0.6644" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1237/1719 [====================>.........] - ETA: 0s - loss: 1.2164 - accuracy: 0.6656" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1268/1719 [=====================>........] - ETA: 0s - loss: 1.2153 - accuracy: 0.6660" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1297/1719 [=====================>........] - ETA: 0s - loss: 1.2148 - accuracy: 0.6659" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1327/1719 [======================>.......] - ETA: 0s - loss: 1.2147 - accuracy: 0.6655" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1354/1719 [======================>.......] - ETA: 0s - loss: 1.2142 - accuracy: 0.6652" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1386/1719 [=======================>......] - ETA: 0s - loss: 1.2135 - accuracy: 0.6655" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1419/1719 [=======================>......] - ETA: 0s - loss: 1.2127 - accuracy: 0.6657" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1450/1719 [========================>.....] - ETA: 0s - loss: 1.2120 - accuracy: 0.6660" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1479/1719 [========================>.....] - ETA: 0s - loss: 1.2114 - accuracy: 0.6658" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1505/1719 [=========================>....] - ETA: 0s - loss: 1.2111 - accuracy: 0.6656" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1532/1719 [=========================>....] - ETA: 0s - loss: 1.2103 - accuracy: 0.6659" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1562/1719 [==========================>...] - ETA: 0s - loss: 1.2090 - accuracy: 0.6665" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1595/1719 [==========================>...] - ETA: 0s - loss: 1.2087 - accuracy: 0.6662" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1621/1719 [===========================>..] - ETA: 0s - loss: 1.2077 - accuracy: 0.6666" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1654/1719 [===========================>..] - ETA: 0s - loss: 1.2066 - accuracy: 0.6669" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1685/1719 [============================>.] - ETA: 0s - loss: 1.2058 - accuracy: 0.6671" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1716/1719 [============================>.] - ETA: 0s - loss: 1.2052 - accuracy: 0.6672" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1719/1719 [==============================] - 3s 2ms/step - loss: 1.2052 - accuracy: 0.6672 - val_loss: 1.1417 - val_accuracy: 0.6812\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 8/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/1719 [..............................] - ETA: 6s - loss: 1.2681 - accuracy: 0.5938" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 32/1719 [..............................] - ETA: 2s - loss: 1.1744 - accuracy: 0.6758" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 61/1719 [>.............................] - ETA: 2s - loss: 1.1631 - accuracy: 0.6778" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 90/1719 [>.............................] - ETA: 2s - loss: 1.1443 - accuracy: 0.6892" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 119/1719 [=>............................] - ETA: 2s - loss: 1.1457 - accuracy: 0.6859" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 151/1719 [=>............................] - ETA: 2s - loss: 1.1466 - accuracy: 0.6846" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 180/1719 [==>...........................] - ETA: 2s - loss: 1.1473 - accuracy: 0.6854" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 207/1719 [==>...........................] - ETA: 2s - loss: 1.1498 - accuracy: 0.6824" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 238/1719 [===>..........................] - ETA: 2s - loss: 1.1521 - accuracy: 0.6801" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 265/1719 [===>..........................] - ETA: 2s - loss: 1.1522 - accuracy: 0.6791" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 296/1719 [====>.........................] - ETA: 2s - loss: 1.1512 - accuracy: 0.6788" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 326/1719 [====>.........................] - ETA: 2s - loss: 1.1507 - accuracy: 0.6796" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 354/1719 [=====>........................] - ETA: 2s - loss: 1.1489 - accuracy: 0.6795" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 386/1719 [=====>........................] - ETA: 2s - loss: 1.1466 - accuracy: 0.6805" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 416/1719 [======>.......................] - ETA: 2s - loss: 1.1459 - accuracy: 0.6805" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 444/1719 [======>.......................] - ETA: 2s - loss: 1.1460 - accuracy: 0.6797" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 475/1719 [=======>......................] - ETA: 2s - loss: 1.1448 - accuracy: 0.6795" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 506/1719 [=======>......................] - ETA: 2s - loss: 1.1434 - accuracy: 0.6798" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 538/1719 [========>.....................] - ETA: 2s - loss: 1.1427 - accuracy: 0.6801" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 565/1719 [========>.....................] - ETA: 1s - loss: 1.1426 - accuracy: 0.6803" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 592/1719 [=========>....................] - ETA: 1s - loss: 1.1429 - accuracy: 0.6786" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 619/1719 [=========>....................] - ETA: 1s - loss: 1.1431 - accuracy: 0.6776" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 650/1719 [==========>...................] - ETA: 1s - loss: 1.1421 - accuracy: 0.6775" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 681/1719 [==========>...................] - ETA: 1s - loss: 1.1420 - accuracy: 0.6770" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 713/1719 [===========>..................] - ETA: 1s - loss: 1.1402 - accuracy: 0.6781" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 742/1719 [===========>..................] - ETA: 1s - loss: 1.1391 - accuracy: 0.6784" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 774/1719 [============>.................] - ETA: 1s - loss: 1.1404 - accuracy: 0.6772" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 803/1719 [=============>................] - ETA: 1s - loss: 1.1406 - accuracy: 0.6764" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 831/1719 [=============>................] - ETA: 1s - loss: 1.1400 - accuracy: 0.6769" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 859/1719 [=============>................] - ETA: 1s - loss: 1.1408 - accuracy: 0.6756" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 887/1719 [==============>...............] - ETA: 1s - loss: 1.1413 - accuracy: 0.6748" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 919/1719 [===============>..............] - ETA: 1s - loss: 1.1400 - accuracy: 0.6754" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 950/1719 [===============>..............] - ETA: 1s - loss: 1.1390 - accuracy: 0.6760" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 978/1719 [================>.............] - ETA: 1s - loss: 1.1390 - accuracy: 0.6754" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1007/1719 [================>.............] - ETA: 1s - loss: 1.1381 - accuracy: 0.6757" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1037/1719 [=================>............] - ETA: 1s - loss: 1.1382 - accuracy: 0.6758" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1066/1719 [=================>............] - ETA: 1s - loss: 1.1372 - accuracy: 0.6761" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1096/1719 [==================>...........] - ETA: 1s - loss: 1.1366 - accuracy: 0.6758" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1127/1719 [==================>...........] - ETA: 1s - loss: 1.1366 - accuracy: 0.6756" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1158/1719 [===================>..........] - ETA: 0s - loss: 1.1362 - accuracy: 0.6755" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1188/1719 [===================>..........] - ETA: 0s - loss: 1.1359 - accuracy: 0.6751" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1215/1719 [====================>.........] - ETA: 0s - loss: 1.1350 - accuracy: 0.6757" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1244/1719 [====================>.........] - ETA: 0s - loss: 1.1349 - accuracy: 0.6757" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1275/1719 [=====================>........] - ETA: 0s - loss: 1.1345 - accuracy: 0.6755" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1307/1719 [=====================>........] - ETA: 0s - loss: 1.1334 - accuracy: 0.6760" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1335/1719 [======================>.......] - ETA: 0s - loss: 1.1323 - accuracy: 0.6762" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1367/1719 [======================>.......] - ETA: 0s - loss: 1.1306 - accuracy: 0.6766" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1397/1719 [=======================>......] - ETA: 0s - loss: 1.1294 - accuracy: 0.6770" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1430/1719 [=======================>......] - ETA: 0s - loss: 1.1283 - accuracy: 0.6772" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1461/1719 [========================>.....] - ETA: 0s - loss: 1.1273 - accuracy: 0.6771" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1490/1719 [=========================>....] - ETA: 0s - loss: 1.1269 - accuracy: 0.6774" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1520/1719 [=========================>....] - ETA: 0s - loss: 1.1267 - accuracy: 0.6775" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1546/1719 [=========================>....] - ETA: 0s - loss: 1.1261 - accuracy: 0.6777" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1576/1719 [==========================>...] - ETA: 0s - loss: 1.1258 - accuracy: 0.6776" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1605/1719 [===========================>..] - ETA: 0s - loss: 1.1254 - accuracy: 0.6779" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1634/1719 [===========================>..] - ETA: 0s - loss: 1.1249 - accuracy: 0.6779" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1662/1719 [============================>.] - ETA: 0s - loss: 1.1246 - accuracy: 0.6777" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1691/1719 [============================>.] - ETA: 0s - loss: 1.1239 - accuracy: 0.6782" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1719/1719 [==============================] - 3s 2ms/step - loss: 1.1231 - accuracy: 0.6785 - val_loss: 1.0683 - val_accuracy: 0.6892\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 9/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/1719 [..............................] - ETA: 4s - loss: 1.0829 - accuracy: 0.7188" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 28/1719 [..............................] - ETA: 3s - loss: 1.0580 - accuracy: 0.7176" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 58/1719 [>.............................] - ETA: 2s - loss: 1.0581 - accuracy: 0.7134" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 88/1719 [>.............................] - ETA: 2s - loss: 1.0622 - accuracy: 0.7042" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 117/1719 [=>............................] - ETA: 2s - loss: 1.0678 - accuracy: 0.6979" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 145/1719 [=>............................] - ETA: 2s - loss: 1.0804 - accuracy: 0.6864" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 171/1719 [=>............................] - ETA: 2s - loss: 1.0763 - accuracy: 0.6888" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 199/1719 [==>...........................] - ETA: 2s - loss: 1.0768 - accuracy: 0.6891" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 229/1719 [==>...........................] - ETA: 2s - loss: 1.0781 - accuracy: 0.6883" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 258/1719 [===>..........................] - ETA: 2s - loss: 1.0809 - accuracy: 0.6850" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 289/1719 [====>.........................] - ETA: 2s - loss: 1.0788 - accuracy: 0.6847" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 320/1719 [====>.........................] - ETA: 2s - loss: 1.0789 - accuracy: 0.6839" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 350/1719 [=====>........................] - ETA: 2s - loss: 1.0780 - accuracy: 0.6850" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 377/1719 [=====>........................] - ETA: 2s - loss: 1.0765 - accuracy: 0.6858" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 407/1719 [======>.......................] - ETA: 2s - loss: 1.0776 - accuracy: 0.6849" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 435/1719 [======>.......................] - ETA: 2s - loss: 1.0769 - accuracy: 0.6860" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 464/1719 [=======>......................] - ETA: 2s - loss: 1.0766 - accuracy: 0.6862" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 496/1719 [=======>......................] - ETA: 2s - loss: 1.0760 - accuracy: 0.6864" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 525/1719 [========>.....................] - ETA: 2s - loss: 1.0761 - accuracy: 0.6861" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 552/1719 [========>.....................] - ETA: 2s - loss: 1.0750 - accuracy: 0.6860" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 584/1719 [=========>....................] - ETA: 1s - loss: 1.0752 - accuracy: 0.6858" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 615/1719 [=========>....................] - ETA: 1s - loss: 1.0745 - accuracy: 0.6862" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 645/1719 [==========>...................] - ETA: 1s - loss: 1.0734 - accuracy: 0.6873" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 677/1719 [==========>...................] - ETA: 1s - loss: 1.0723 - accuracy: 0.6877" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 706/1719 [===========>..................] - ETA: 1s - loss: 1.0715 - accuracy: 0.6868" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 735/1719 [===========>..................] - ETA: 1s - loss: 1.0709 - accuracy: 0.6863" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 764/1719 [============>.................] - ETA: 1s - loss: 1.0708 - accuracy: 0.6865" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 792/1719 [============>.................] - ETA: 1s - loss: 1.0694 - accuracy: 0.6879" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 824/1719 [=============>................] - ETA: 1s - loss: 1.0693 - accuracy: 0.6877" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 854/1719 [=============>................] - ETA: 1s - loss: 1.0687 - accuracy: 0.6879" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 882/1719 [==============>...............] - ETA: 1s - loss: 1.0687 - accuracy: 0.6876" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 913/1719 [==============>...............] - ETA: 1s - loss: 1.0684 - accuracy: 0.6877" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 943/1719 [===============>..............] - ETA: 1s - loss: 1.0678 - accuracy: 0.6874" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 971/1719 [===============>..............] - ETA: 1s - loss: 1.0684 - accuracy: 0.6868" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 997/1719 [================>.............] - ETA: 1s - loss: 1.0672 - accuracy: 0.6873" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1026/1719 [================>.............] - ETA: 1s - loss: 1.0670 - accuracy: 0.6872" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1055/1719 [=================>............] - ETA: 1s - loss: 1.0664 - accuracy: 0.6874" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1086/1719 [=================>............] - ETA: 1s - loss: 1.0653 - accuracy: 0.6874" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1116/1719 [==================>...........] - ETA: 1s - loss: 1.0659 - accuracy: 0.6872" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1146/1719 [===================>..........] - ETA: 0s - loss: 1.0653 - accuracy: 0.6875" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1174/1719 [===================>..........] - ETA: 0s - loss: 1.0652 - accuracy: 0.6874" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1202/1719 [===================>..........] - ETA: 0s - loss: 1.0649 - accuracy: 0.6873" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1230/1719 [====================>.........] - ETA: 0s - loss: 1.0652 - accuracy: 0.6871" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1261/1719 [=====================>........] - ETA: 0s - loss: 1.0647 - accuracy: 0.6874" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1286/1719 [=====================>........] - ETA: 0s - loss: 1.0646 - accuracy: 0.6872" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1317/1719 [=====================>........] - ETA: 0s - loss: 1.0642 - accuracy: 0.6870" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1346/1719 [======================>.......] - ETA: 0s - loss: 1.0645 - accuracy: 0.6870" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1373/1719 [======================>.......] - ETA: 0s - loss: 1.0642 - accuracy: 0.6873" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1402/1719 [=======================>......] - ETA: 0s - loss: 1.0642 - accuracy: 0.6870" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1432/1719 [=======================>......] - ETA: 0s - loss: 1.0632 - accuracy: 0.6872" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1462/1719 [========================>.....] - ETA: 0s - loss: 1.0628 - accuracy: 0.6871" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1488/1719 [========================>.....] - ETA: 0s - loss: 1.0626 - accuracy: 0.6868" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1520/1719 [=========================>....] - ETA: 0s - loss: 1.0618 - accuracy: 0.6868" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1548/1719 [==========================>...] - ETA: 0s - loss: 1.0612 - accuracy: 0.6871" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1578/1719 [==========================>...] - ETA: 0s - loss: 1.0605 - accuracy: 0.6876" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1610/1719 [===========================>..] - ETA: 0s - loss: 1.0595 - accuracy: 0.6877" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1642/1719 [===========================>..] - ETA: 0s - loss: 1.0593 - accuracy: 0.6876" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1670/1719 [============================>.] - ETA: 0s - loss: 1.0585 - accuracy: 0.6876" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1698/1719 [============================>.] - ETA: 0s - loss: 1.0580 - accuracy: 0.6879" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1719/1719 [==============================] - 3s 2ms/step - loss: 1.0574 - accuracy: 0.6880 - val_loss: 1.0099 - val_accuracy: 0.7012\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 10/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/1719 [..............................] - ETA: 5s - loss: 0.9283 - accuracy: 0.8125" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 29/1719 [..............................] - ETA: 3s - loss: 1.0348 - accuracy: 0.7004" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 55/1719 [..............................] - ETA: 3s - loss: 1.0449 - accuracy: 0.6909" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 86/1719 [>.............................] - ETA: 2s - loss: 1.0367 - accuracy: 0.6930" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 112/1719 [>.............................] - ETA: 2s - loss: 1.0358 - accuracy: 0.6881" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 139/1719 [=>............................] - ETA: 2s - loss: 1.0318 - accuracy: 0.6936" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 169/1719 [=>............................] - ETA: 2s - loss: 1.0298 - accuracy: 0.6914" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 201/1719 [==>...........................] - ETA: 2s - loss: 1.0312 - accuracy: 0.6880" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 233/1719 [===>..........................] - ETA: 2s - loss: 1.0355 - accuracy: 0.6862" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 263/1719 [===>..........................] - ETA: 2s - loss: 1.0310 - accuracy: 0.6882" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 293/1719 [====>.........................] - ETA: 2s - loss: 1.0301 - accuracy: 0.6876" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 323/1719 [====>.........................] - ETA: 2s - loss: 1.0283 - accuracy: 0.6888" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 352/1719 [=====>........................] - ETA: 2s - loss: 1.0281 - accuracy: 0.6903" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 382/1719 [=====>........................] - ETA: 2s - loss: 1.0267 - accuracy: 0.6915" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 410/1719 [======>.......................] - ETA: 2s - loss: 1.0283 - accuracy: 0.6904" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 440/1719 [======>.......................] - ETA: 2s - loss: 1.0250 - accuracy: 0.6919" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 471/1719 [=======>......................] - ETA: 2s - loss: 1.0272 - accuracy: 0.6918" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 497/1719 [=======>......................] - ETA: 2s - loss: 1.0281 - accuracy: 0.6912" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 527/1719 [========>.....................] - ETA: 2s - loss: 1.0284 - accuracy: 0.6905" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 554/1719 [========>.....................] - ETA: 2s - loss: 1.0268 - accuracy: 0.6915" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 586/1719 [=========>....................] - ETA: 1s - loss: 1.0248 - accuracy: 0.6929" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 618/1719 [=========>....................] - ETA: 1s - loss: 1.0237 - accuracy: 0.6934" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 648/1719 [==========>...................] - ETA: 1s - loss: 1.0238 - accuracy: 0.6927" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 680/1719 [==========>...................] - ETA: 1s - loss: 1.0231 - accuracy: 0.6921" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 710/1719 [===========>..................] - ETA: 1s - loss: 1.0218 - accuracy: 0.6928" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 741/1719 [===========>..................] - ETA: 1s - loss: 1.0205 - accuracy: 0.6932" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 771/1719 [============>.................] - ETA: 1s - loss: 1.0195 - accuracy: 0.6931" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 800/1719 [============>.................] - ETA: 1s - loss: 1.0192 - accuracy: 0.6935" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 830/1719 [=============>................] - ETA: 1s - loss: 1.0194 - accuracy: 0.6934" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 859/1719 [=============>................] - ETA: 1s - loss: 1.0190 - accuracy: 0.6935" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 889/1719 [==============>...............] - ETA: 1s - loss: 1.0178 - accuracy: 0.6942" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 919/1719 [===============>..............] - ETA: 1s - loss: 1.0162 - accuracy: 0.6954" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 949/1719 [===============>..............] - ETA: 1s - loss: 1.0151 - accuracy: 0.6959" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 980/1719 [================>.............] - ETA: 1s - loss: 1.0149 - accuracy: 0.6960" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1009/1719 [================>.............] - ETA: 1s - loss: 1.0145 - accuracy: 0.6961" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1039/1719 [=================>............] - ETA: 1s - loss: 1.0137 - accuracy: 0.6963" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1071/1719 [=================>............] - ETA: 1s - loss: 1.0131 - accuracy: 0.6961" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1095/1719 [==================>...........] - ETA: 1s - loss: 1.0121 - accuracy: 0.6966" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1125/1719 [==================>...........] - ETA: 1s - loss: 1.0122 - accuracy: 0.6964" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1155/1719 [===================>..........] - ETA: 0s - loss: 1.0117 - accuracy: 0.6964" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1185/1719 [===================>..........] - ETA: 0s - loss: 1.0114 - accuracy: 0.6967" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1213/1719 [====================>.........] - ETA: 0s - loss: 1.0109 - accuracy: 0.6968" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1240/1719 [====================>.........] - ETA: 0s - loss: 1.0107 - accuracy: 0.6966" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1271/1719 [=====================>........] - ETA: 0s - loss: 1.0101 - accuracy: 0.6964" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1299/1719 [=====================>........] - ETA: 0s - loss: 1.0091 - accuracy: 0.6970" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1330/1719 [======================>.......] - ETA: 0s - loss: 1.0085 - accuracy: 0.6974" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1359/1719 [======================>.......] - ETA: 0s - loss: 1.0077 - accuracy: 0.6974" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1385/1719 [=======================>......] - ETA: 0s - loss: 1.0070 - accuracy: 0.6980" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1413/1719 [=======================>......] - ETA: 0s - loss: 1.0062 - accuracy: 0.6986" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1444/1719 [========================>.....] - ETA: 0s - loss: 1.0064 - accuracy: 0.6980" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1473/1719 [========================>.....] - ETA: 0s - loss: 1.0067 - accuracy: 0.6977" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1502/1719 [=========================>....] - ETA: 0s - loss: 1.0068 - accuracy: 0.6978" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1532/1719 [=========================>....] - ETA: 0s - loss: 1.0065 - accuracy: 0.6980" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1564/1719 [==========================>...] - ETA: 0s - loss: 1.0061 - accuracy: 0.6982" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1589/1719 [==========================>...] - ETA: 0s - loss: 1.0057 - accuracy: 0.6981" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1615/1719 [===========================>..] - ETA: 0s - loss: 1.0058 - accuracy: 0.6978" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1643/1719 [===========================>..] - ETA: 0s - loss: 1.0052 - accuracy: 0.6980" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1670/1719 [============================>.] - ETA: 0s - loss: 1.0049 - accuracy: 0.6979" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1696/1719 [============================>.] - ETA: 0s - loss: 1.0043 - accuracy: 0.6979" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1719/1719 [==============================] - 3s 2ms/step - loss: 1.0041 - accuracy: 0.6979 - val_loss: 0.9619 - val_accuracy: 0.7080\n" + ] + } + ], + "source": [ + "history = model.fit(X_train, y_train, epochs=10,\n", + " validation_data=(X_valid, y_valid))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Model history" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The fit method returns the model history, which contains the training parameters (`history.parms`) and a dictionary containing the loss and additional metrics computed during training (`history.history`)." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:49.633964Z", + "iopub.status.busy": "2024-01-10T00:21:49.633518Z", + "iopub.status.idle": "2024-01-10T00:21:49.639843Z", + "shell.execute_reply": "2024-01-10T00:21:49.639189Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'verbose': 1, 'epochs': 10, 'steps': 1719}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "history.params" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:49.642886Z", + "iopub.status.busy": "2024-01-10T00:21:49.642384Z", + "iopub.status.idle": "2024-01-10T00:21:49.649058Z", + "shell.execute_reply": "2024-01-10T00:21:49.648469Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "history.history.keys()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Let's plot the history." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:49.652051Z", + "iopub.status.busy": "2024-01-10T00:21:49.651605Z", + "iopub.status.idle": "2024-01-10T00:21:49.836963Z", + "shell.execute_reply": "2024-01-10T00:21:49.836387Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqgAAAHECAYAAAD1ZtjgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8WgzjOAAAACXBIWXMAAA9hAAAPYQGoP6dpAACgsklEQVR4nOzdd3hUZdrH8e+ZyaT3XklIoUNAepHepVsREUTs4CpWVteyq2JZXey+NlApNqoCQiihdwgQSEIS0nvvZZKZ948JA6EIoUxCcn+85pqZM6fckxPwx3Oe5zmKXq/XI4QQQgghRBOhauwChBBCCCGEOJ8EVCGEEEII0aRIQBVCCCGEEE2KBFQhhBBCCNGkSEAVQgghhBBNigRUIYQQQgjRpEhAFUIIIYQQTYoEVCGEEEII0aRIQBVCCCGEEE2KBFQhhBBCCNGkNCigLliwgJ49e2JnZ4e7uzuTJk0iJibmb7f55ptvuP3223FycsLJyYnhw4dz4MCBeuvMnDkTRVHqPUaPHt3wbyOEEEIIIW55DQqo27dv56mnnmLfvn2EhYWh1WoZOXIkZWVll90mPDycqVOnsm3bNvbu3Yufnx8jR44kLS2t3nqjR48mIyPD+Fi+fPm1fSMhhBBCCHFLU/R6vf5aN87JycHd3Z3t27czcODAq9qmtrYWJycnPvvsMx588EHA0IJaWFjI6tWrr6kOnU5Heno6dnZ2KIpyTfsQQgghhBA3j16vp6SkBG9vb1Sqv28jNbueAxUVFQHg7Ox81duUl5ej1Wov2iY8PBx3d3ecnJwYOnQob731Fi4uLpfcR1VVFVVVVcb3aWlpdOjQ4Rq+gRBCCCGEMKWUlBR8fX3/dp1rbkHV6XRMmDCBwsJCdu3addXbPfnkk2zcuJGTJ09iaWkJwM8//4y1tTWtW7cmPj6ef/7zn9ja2rJ3717UavVF+3jjjTd48803L1r+7bffYm1tfS1fRwghhBBC3ETl5eXMnj2bwsJCHBwc/nbdaw6oTzzxBBs2bGDXrl1XTMFnvfvuu7z//vuEh4fTpUuXy6535swZgoKC2Lx5M8OGDbvo8wtbUIuLi/Hz8yM3Nxd7e/uGf5lroNVqCQsLY8SIEWg0GpMcUzQuOectj5zzlkfOecsk5900iouLcXV1paio6Ip57Zou8c+ZM4c///yTHTt2XHU4/e9//8u7777L5s2b/zacAgQGBuLq6kpcXNwlA6qFhQUWFhYXLddoNCb/xWqMY4rGJee85ZFz3vLIOW+Z5LzfXA352TYooOr1eubOncuqVasIDw+ndevWV7Xd+++/z9tvv83GjRvp0aPHFddPTU0lLy8PLy+vhpQnhBBCCCGagQZNM/XUU0+xZMkSli1bhp2dHZmZmWRmZlJRUWFc58EHH2T+/PnG9++99x7/+te/+P777wkICDBuU1paCkBpaSkvvPAC+/btIzExkS1btjBx4kSCg4MZNWrUDfqaQgghhBDiVtGgFtQvv/wSgMGDB9dbvmjRImbOnAlAcnJyvakDvvzyS6qrq7nrrrvqbfP666/zxhtvoFarOX78OD/88AOFhYV4e3szcuRI/vOf/1zyMr4QQgghTE+v11NTU0NtbW1jl3LDabVazMzMqKysbJbfz5TUajVmZmbXPe1ngy/xX0l4eHi994mJiX+7vpWVFRs3bmxIGUIIIYQwoerqajIyMigvL2/sUm4KvV6Pp6cnKSkpMp/6DWBtbY2Xlxfm5ubXvI/rmgdVCCGEEM2bTqcjISEBtVqNt7c35ubmzS7E6XQ6SktLsbW1veIE8uLy9Ho91dXV5OTkkJCQQEhIyDX/PCWgCiGEEOKyqqur0el0+Pn5Ndu5xnU6HdXV1VhaWkpAvU5WVlZoNBqSkpKMP9NrIWdBCCGEEFckwU1crRvxuyK/bUIIIYQQokmRgCqEEEKIZmnw4ME888wzjV2GuAYSUIUQQgghRJMiAVUIIYQQQjQpElCvUUllTWOXIIQQQoirVFBQwIMPPoiTkxPW1taMGTOG2NhY4+fJyclMmDABJycnbGxs6NixI+vXrzduO23aNNzc3LCysiIkJIRFixY11ldpEWSaqWsQl13K5C92M9BNYXiNDo2msSsSQgghTEOv11OhbZy7LVlp1Nc8B+vMmTOJjY1l7dq12Nvb89JLLzF27FhOnTqFWq3mhRdeQKfTsWPHDmxsbDh16hS2trYA/Otf/+LUqVNs2LABV1dX4uLi6t3mXdx4ElCvwYojqZRU1rAuRU3MF3tZcGcXegY4N3ZZQgghxE1Xoa2lw2uNcwfIU/8ehbV5w6PL2WC6e/du+vXrB8DSpUvx8/Nj9erV3HnnnaSmpnL33XfTuXNnAAIDA43bJycn061bN3r06AFAQEDA9X8Z8bfkEv81eHFUW/57V2dszfTE5ZRx91d7mb/yBEXl2sYuTQghhBAXiIqKwszMjN69exuXubi40LZtW6KiogB47LHHePvtt+nfvz+vv/46x48fN677xBNP8PPPP9O1a1defPFF9uzZY/Lv0NJIC+o1UBSFiaFeVCce5ajen98Op7H8QDJhp7J4bXwHxnfxana3gRNCCCHAcJn91L9HNdqxb5YHH3yQiRMnsmHDBjZt2sSCBQv48MMPmTt3LmPGjCEpKYn169cTFhbGsGHDeOqpp/jvf/970+pp6aQF9TrYaOCdSR355dE+BLnZkFtaxdPLjzJz0UFS8ssbuzwhhBDihlMUBWtzs0Z5XGvjT/v27ampqWH//v3GZXl5ecTExNChQwfjMj8/Px5//HFWrlzJc889xzfffGP8zM3NjRkzZrBkyRIWLlzI119/fe0/RHFFElBvgN6BLqz/x+3MG9EGc7WK7adzGPG/7Xy1PR5tra6xyxNCCCFatJCQECZOnMgjjzzCrl27OHbsGA888AA+Pj5MnDgRgPnz57Nx40YSEhI4cuQI27Zto3379gC89tprrFmzhri4OE6ePMmff/5p/EzcHBJQbxALMzVPDwvhr2dup2+gC5VaHe9uiGb8p7s4klzQ2OUJIYQQLdqiRYvo3r0748aNo2/fvuj1etavX4+mbiqe2tpa5s6dS/v27Rk9ejRt2rThiy++AMDc3Jz58+fTpUsXBg4ciFqt5ueff27Mr9PsSR/UGyzQzZZlj/RmxZE03l53iujMEu78cg8P9PbnhdFtsbeUOamEEEIIUwgPDze+dnJy4scff7zsuu+//z729vaoVBe33b366qu8+uqrN6NEcRnSgnoTKIrCXd192fLcYO68zRe9Hn7al8TwD7ez/kQGer2+sUsUQgghhGiyJKDeRM425nx4TyjLZvemtasN2SVVPLn0CLN/OERaoUzwK4QQQghxKRJQTaBfsCsb/nE7Tw8NRqNW2BKdzYiPtvPtzjPUyCAqIYQQQoh6JKCaiKVGzbyRbdnwj9vpFeBMeXUtb62LYuLnuzmeWtjY5QkhhBBCNBkSUE0s2N2Onx/tw7tTOmNvacbJ9GImfb6bN/84SWlVTWOXJ4QQQgjR6CSgNgKVSuG+Xq3Y8txgJnX1RqeHRbsTGfHRdjadzGzs8oQQQgghGpUE1EbkZmfBwvu68eOsXrRytiajqJJHfzrMoz8eIqNIBlEJIYQQomWSgNoEDGzjxqZnB/Lk4CDMVAqbTmUx/MPtLNqdQK1OpqQSQgghRMsiAbWJsNSoeXF0O/58egC3tXKkrLqWN/84xeQvdhOZVtTY5QkhhBBCmIwE1Camnac9vz/ej7cmdcLO0ozjqUVM/Hw3b687RXm1DKISQgghRPMnAbUJUqkUHujjz5Z5g7ijixe1Oj3f7ExgxEc72Bqd1djlCSGEEELcVBJQmzB3e0s+v/82Fs3siY+jFWmFFcxafIinlh4hu7iyscsTQgghRANotdrGLuGWIQH1FjCknTth8wby2MBA1CqFdScyGPbhdn7al4ROBlEJIYQQl/TXX38xYMAAHB0dcXFxYdy4ccTHxxs/T01NZerUqbi6uuLj40OvXr3Yv3+/8fM//viDnj17YmlpiaurK5MnTzZ+pigKq1evrnc8R0dHFi9eDEBiYiKKovDLL78waNAgLC0tWbp0KXl5eUydOhUfHx+sra3p3Lkzy5cvr7cfnU7H+++/T3BwMBYWFrRq1Yq3334bgKFDhzJnzpx66+fk5GBubs6WLVtuxI+tSZCAeo30etMGQ2tzM+aPbc/aOf0J9XWgpKqGf62O5M6v9hCdWWzSWoQQQrRgej1UlzXOo4H/7y0rK2PevHkcOnSILVu2oFKpmDx5MjqdjtLSUgYNGkRaWhqrV69m586dPP/88+h0hluQr1u3jsmTJzN27FiOHj3Kli1b6NWrV4N/XC+//DL/+Mc/iIqKYtSoUVRWVtK9e3fWrVtHZGQkjz76KNOnT+fAgQPGbebPn8+7777Lv/71L06dOsWyZcvw8PAAYPbs2Sxbtoyqqirj+kuWLMHHx4ehQ4c2uL6myqyxC7gV5Vbk8njY43Sv7s4Y/RiTHrujtwMrn+zPkn1JfLAxhqPJhYz7ZBezbw/kH8NCsDJXm7QeIYQQLYy2HN7xbpxj/zMdzG2uevU777yz3vvvv/8eNzc3Tp06xZ49e8jJyeHgwYM4OjpSXFxM165dUakMbXdvv/029913H2+++aZx+9DQ0AaX/MwzzzBlypR6y55//nnj67lz57Jx40Z+/fVXevXqRUlJCR9//DGfffYZM2bMACAoKIgBAwYAMGXKFObMmcOaNWu45557AFi8eDEzZ85EUZQG19dUSQvqNfg+8ntiCmJYVr6MJ7c9SXxh/JU3uoHUKoUZ/QIImzeQ0R09qdHp+Wp7PCMXbmf76RyT1iKEEEI0VbGxsUydOpXAwEDs7e0JCAgAIDk5mYiICLp164azs/Mlt42IiGDYsGHXXUOPHj3qva+treU///kPnTt3xtnZGVtbWzZu3EhycjIAUVFRVFVVXfbYlpaWTJ8+ne+//x6AI0eOEBkZycyZM6+71qZEWlCvwZyuc7BQLFh8cjH7M/dz59o7mdpuKk90fQJ7c3uT1eHlYMVX07sTdiqL19ZEkpJfwYzvDzAh1Jt/jeuAm52FyWoRQgjRQmisDS2ZjXXsBhg/fjz+/v588803eHt7o9Pp6NSpE9XV1VhZWf3ttlf6XFGUi7r7XWoQlI1N/RbfDz74gI8//piFCxfSuXNnbGxseOaZZ6iurr6q44LhMn/Xrl1JTU1l0aJFDB06FH9//ytudytpUAvqggUL6NmzJ3Z2dri7uzNp0iRiYmKuuN1vv/1Gu3btsLS0pHPnzqxfv77e53q9ntdeew0vLy+srKwYPnw4sbGxDfsmJmStsebJ0Cd52u5phvgOoVZfy5KoJYxfNZ4Vp1dQq6s1aT0jOngQNm8Qs/q3RqXA2mPpDPswnOUHkmUQlRBCiBtLUQyX2Rvj0YBL2Hl5ecTExPDqq68ybNgw2rdvT0FBgfHzLl26EBERQX5+/iW379Kly98OOnJzcyMjI8P4PjY2lvLy8ivWtXv3biZOnMgDDzxAaGgogYGBnD592vh5SEgIVlZWf3vszp0706NHD7755huWLVvGrFmzrnjcW02DAur27dt56qmn2LdvH2FhYWi1WkaOHElZWdllt9mzZw9Tp07l4Ycf5ujRo0yaNIlJkyYRGRlpXOf999/nk08+4auvvmL//v3Y2NgYOxI3Zc5qZz4c+CH/N+L/CHQIJL8ynzf2vsH96+8nIjvCpLXYWpjx2vgOrHlqAJ187CmurGH+yhPc+/VeYrNKTFqLEEII0dicnJxwcXHh66+/Ji4ujq1btzJv3jzj51OnTsXT05NJkyaxe/duEhMTWbFiBXv37gXg9ddfZ/ny5bz++utERUVx4sQJ3nvvPeP2Q4cO5bPPPuPo0aMcOnSIxx9/HI1Gc8W6QkJCCAsLY8+ePURFRfHYY4+RlXVujnNLS0teeuklXnzxRX788Ufi4+PZt28f3333Xb39zJ49m3fffRe9Xl9vdoFmQ38dsrOz9YB++/btl13nnnvu0d9xxx31lvXu3Vv/2GOP6fV6vV6n0+k9PT31H3zwgfHzwsJCvYWFhX758uVXVUdRUZEe0BcVFV3Dt7g21dXV+tWrV+urq6sN72ur9T+e/FHfZ2kffafFnfSdFnfSz98xX59VlmWyms7S1tTqv915Rt/+Xxv0/i/9qQ/+5zr9fzdG6yuqa0xeS3Ny4TkXzZ+c85ZHzvnFKioq9KdOndJXVFQ0dikNFhYWpm/fvr3ewsJC36VLF314eLge0K9atUqv1+v1iYmJ+jvvvFNvb2+vt7a21vfo0UO/f/9+4/YrVqzQd+3aVW9ubq53dXXVT5kyxfhZWlqafuTIkXobGxt9SEiIfv369XoHBwf9okWL9Hq9Xp+QkKAH9EePHq1XU15enn7ixIl6W1tbvbu7u/7VV1/VP/jgg/qJEyca16mtrdW/9dZben9/f71Go9G3atVK/84779TbT0lJid7a2lr/5JNP3tCf2Y1wud+ZhuS16+qDWlRkuEf85ToYA+zdu7fev1gARo0aZZw7LCEhgczMTIYPH2783MHBgd69e7N3717uu+++6ynRZDQqDdM7TGds67F8cvQTVsWu4o8zf7AleQuPdnmU6R2mY642N0ktZmoVDw9ozehOnry+JpLNUdl8ujWOP46l8/bkzvQPdjVJHUIIIURjGj58OKdOnaq3TH9ev1F/f39+//13dDodxcXF2NvbG0fxg2HE/IUj8M/y9vZm48aN9ZYVFhYaXwcEBFxySkpnZ+eL5k+9kEql4pVXXuGVV1657Dq5ublUVlby8MMP/+2+blXXHFB1Oh3PPPMM/fv3p1OnTpddLzMz0zh311keHh5kZmYaPz+77HLrXKiqqqre/F/FxYZ5QLVarcnu0nD2OBcez97Mnld7vsrkwMm8f+h9TuSdYOGRhaw4vYLnuz/P7T63m6Q+AHcbM76YGsqmU9n8Z100iXnlTPt2P5O7evHS6La42JgmMDcXlzvnovmSc97yyDm/mFarRa/Xo9PpjHOENjdng+TZ79mUabVa8vLyeOWVV+jTpw9du3ZtcjXrdDr0ej1arRa1+tz0lw35c3XNAfWpp54iMjKSXbt2XesurtmCBQvqzUt21qZNm7C2btgIv+sVFhZ22c/u1t9NG+s2bKzYSEppCv/Y/g/amLVhrNVYXNWmbcV8th2sS1GxK1NhVUQGGyPTmeivo7ebviF9zgV/f85F8yTnvOWRc36OmZkZnp6elJaWGkeaN1clJU1/zMauXbsYP348wcHBLF682NhI15RUV1dTUVHBjh07qKmpMS6/mkFkZ11TQJ0zZw5//vknO3bswNfX92/X9fT0rNf5FyArKwtPT0/j52eXeXl51Vuna9eul9zn/Pnz63UbKC4uxs/Pj5EjR2Jvb5ppnrRaLWFhYYwYMeJvO0WPYxzPaJ/h28hvWRqzlNM1pzlTdoZpbacxu9NsbDRXP+Hw9boTiEgp5F9rThGdVcryeDXxtU78Z0IHAt1MV8et6mrPuWg+5Jy3PHLOL1ZZWUlKSgq2trZYWlo2djk3hV6vp6SkBDs7uyY/2f3YsWOprTXtbEENVVlZiZWVFQMHDqz3O9OQMN2ggKrX65k7dy6rVq0iPDyc1q1bX3Gbvn37smXLFp555hnjsrCwMPr27QtA69at8fT0ZMuWLcZAWlxczP79+3niiScuuU8LCwssLC6e41Oj0Zj8L5SrOaajxpHnez3PXW3v4v2D77MzbSc/RP3AusR1PNv9WcYFjkOlmOaeCT0D3fjj6dv5flcC/9t8mgOJBYz/fC9PDgniicFBWJjJnaiupDF+z0TjknPe8sg5P6e2thZFUVCpVPX6ZzYnZy+Rn/2e4vqoVCoURbnoz1FD/kw16Cw89dRTLFmyhGXLlmFnZ0dmZiaZmZlUVFQY13nwwQeZP3++8f0//vEP/vrrLz788EOio6N54403OHToEHPmzAEMvwzPPPMMb731FmvXruXEiRM8+OCDeHt7M2nSpIaU1+QFOATwxfAv+HzY5/jb+5Nbkcsru15h+obpROZGXnkHN4hGreKxQUGEPTuIwW3dqK7VsXBzLGM+3sm+M3kmq0MIIYQQ4lIaFFC//PJLioqKGDx4MF5eXsbHL7/8YlwnOTm53sS1/fr1Y9myZXz99deEhoby+++/s3r16noDq1588UXmzp3Lo48+Ss+ePSktLeWvv/5qtpcSBvoOZOWElTzb/Vmszaw5nnOc+9fdz+t7XievwnQB0c/ZmkUze/LZ/d1wtbXgTE4Z9329jxd/P0ZBWfPuZySEEEKIpqvBl/ivJDw8/KJld999N3ffffdlt1EUhX//+9/8+9//bkg5tzRztTmzOs1iXOA4Fh5eyB9n/mBl7Eo2JW7iidAnmNp+KhrVzb+8pCgK47p4c3uIG+/9Fc2y/cn8eiiVzVHZ/GtceyZ19Wny/XGEEEII0bxIR4tG5m7tzju3v8NPY36ig0sHSrWlfHDoA+5aexd70veYrA4HKw3vTO7Miif60sbDlvyyap795RjTvztAYu7l7xQmhBBCCHGjSUBtIrq6d2X5Hct5s9+bOFs6c6boDI+FPcY/tv6DlJIUk9XR3d+ZP+fezguj2mJhpmJXXC4jF+7gs62xVNc0rXnWhBBCCNE8SUBtQlSKiikhU/hj8h880P4B1IqarSlbmbR6Ep8c+YRy7dXPH3Y9zM1UPDUkmE3PDuT2EFeqa3T8d9Np7vhkJwcT801SgxBCCNHYAgICWLhw4VWtqyjKFe8QJa6eBNQmyN7cnpd6vcSKCSvo49WHal0135z4hgmrJ7AhYcNV9QW+EfxdbPhxVi8W3tsVFxtzYrNLufurvcxfeZy80qor70AIIYQQ4hpIQG3CghyD+HrE1ywcshAfWx+yyrN4cceLzPxrJtH50SapQVEUJnXzYctzg7i3hx8Ayw+kMOiDcD7fFkdFddOeLFgIIYQQtx4JqE2coigMazWM1RNXM6frHCzVlhzJPsK9f97LW/veorCy0CR1OFqb895dXfj1sb508rGntKqGDzbGMPi/2/j1YAq1OtO06gohhBBX4+uvv8bb2/ui+9RPnDiRWbNmER8fz8SJE/Hw8MDe3p6hQ4eyefPmG3b8EydOMHToUKysrHBxceHRRx+ltLTU+Hl4eDi9evXCxsYGR0dH+vfvT1JSEgDHjh1jyJAh2NnZYW9vT/fu3Tl06NANq+1WIAH1FmFpZsljoY/xx+Q/GBMwBp1exy8xv3DHqjtYHr2cGl3NlXdyA/Rq7czapwbw8X1d8XG0Iqu4ihdXHGfsxzvZFp1tsu4HQgghGoder6dcW94oj4b8P+buu+8mLy+Pbdu2GZfl5+fz119/MW3aNEpLSxk7dixbtmzh8OHDDBs2jIkTJ5KcnHzdP6OysjJGjRqFk5MTBw8e5LfffmPz5s3GmxTV1NQwadIkBg0axPHjx9m7dy+PPvqocVrHadOm4evry8GDBzl8+DAvv/xyi7uzWYPmQRWNz9PGk/cHvc89be9hwYEFnC44zTv73+G3078xv9d8enr2vOk1qFQKE7v6MLqTJz/tTeLTrXHEZJXw0OKD9AtyYf6Y9nT2dbjpdQghhDC9ipoKei/r3SjH3n//fqw11le1rpOTE2PGjGHZsmUMGzYMgN9//x1XV1eGDBmCSqUiNDQUMNzq9JVXXmHDhg2sXbvWGCSv1bJly6isrOTHH3/ExsYGgM8++4zx48fz3nvvodFoKCoqYty4cQQFBQHQvn174/bJycm88MILtGvXDoCQkJDrqudWJC2ot6genj34ZdwvvNr7VRwsHIgtiGXWxlk8F/4cGaUZV97BDWBhpmb27YHseGEIjw0MxNxMxZ74PMZ/tot//HyUlHzTzDoghBBCXMq0adNYsWIFVVWGgb1Lly7lvvvuQ6VSUVpayvPPP0/79u1xdnbG19eXqKioG9KCGhUVRWhoqDGcAvTv3x+dTkdMTAzOzs7MnDmTUaNGMX78eD7++ON6d+GcN28es2fPZvjw4bz77rvEx8dfd023GmlBvYWZqcy4t929jAoYxWcRn/Hb6d/YlLSJHak7mNV5Fg91fAhLs5t/u1gHaw3zx7Znel9/Ptx0mlVH01gTkc6GE5k82NefOUODcbQ2v+l1CCGEuPmszKzYf//+Rjt2Q4wfPx69Xs+6devo2bMnO3fu5H//+x8Azz//PGFhYfz3v/8lMDCQ2tpaZs2aRXW1aW71vWjRIp5++mn++usvfvnlF1599VXCwsLo06cPb7zxBvfffz/r1q1jw4YNvP766/z8889MnjzZJLU1BdKC2gw4Wjryap9X+XXcr/Tw6EFlbSVfRHzBxNUT2Zy02WT9Qn2drPnfvV35c+4A+ge7UF2r49tdCQx8fxtf74inUisj/oUQ4lanKArWGutGeTT01tuWlpZMmTKFpUuXsnz5ctq2bcttt90GwO7du5k5cyaTJ0+mc+fOuLu7k5iYeEN+Ru3bt+fYsWOUlZ27E+Pu3btRqVS0bdvWuKxbt27Mnz+fPXv20KlTJ5YtW2b8rE2bNjz77LNs2rSJKVOmsGjRohtS261CAmoz0ta5Ld+P+p4PBn2Ap40n6WXpPBv+LI+EPUJcQZzJ6ujk48CSh3vzw6xetPO0o7iyhnfWRzPsw+2sOpqKTkb8CyGEMJFp06axbt06vv/+e6ZNm2ZcHhISwsqVK4mIiODYsWM88sgjF434v55jWlpaMmPGDCIjI9m2bRtz585l+vTpeHh4kJCQwPz589m7dy9JSUls2rSJ2NhY2rdvT0VFBXPmzCE8PJykpCR2797NwYMH6/VRbQkkoDYziqIwOmA0ayau4bEuj2GuMmd/xn7u+uMu3j3wLkVVRSarY1AbN9Y9fTv/vTsULwdL0gorePaXY4z/bBe7YnNNUocQQoiWbejQoTg7OxMTE8P9999vXP7RRx/h5OREv379mDhxIkOHDjW2rl4va2trNm7cSH5+Pj179uSuu+5i2LBhfPbZZ8bPo6OjufPOO2nTpg2PPvooTz31FI899hhqtZq8vDwefPBB2rRpwz333MOYMWN48803b0httwpF3wzmBSouLsbBwYGioiLs7e1NckytVsv69esZO3Zsk576IbUklQ8PfcjmZMPcbk4WTjx929NMDp6MWqU2WR2V2lq+353Al9viKakyTIk1sI0b88e0o72Xac7Z9bpVzrm4ceSctzxyzi9WWVlJQkICrVu3xtLy5o9raAw6nY7i4mLs7e1RqaTt7npd7nemIXlNzkIz52vny/+G/I+vR3xNkEMQBVUFvLn3Taaum8rR7KMmq8NSo+bJwcFsf3EID/UPQKNW2HE6h7Gf7OT5346RXlhhslqEEEII0bRJQG0h+nr35bcJv/FSz5ew09gRlR/Fgxse5OWdL5NVlmWyOpxtzHl9fEc2zxvEHV280Ovh98OpDPlvOO/9FU1xpdZktQghhBBXY+nSpdja2l7y0bFjx8Yur1mSaaZaEI1KwwMdHmBM6zF8evRTVsauZN2ZdWxN3sqjXR7lwQ4PYq42zXRQ/i42fH7/bcweUMCCDdEcSMjny/B4fj6QzNPDQpjW2x9zM/n3kxBCiMY3YcIEeve+9M0JpCvIzSEJoAVysXLhjX5vsHzcckLdQqmoqeDjIx8zac0kwlPCTXq70m6tnPjl0T58+2APgt1tKSjX8uYfpxj+0Xb+PJ4ut04VQgjR6Ozs7AgODr7kw9/fv7HLa5YkoLZgHV068tOYn3hnwDu4WbmRUpLC3K1zeWLLEyQUJZisDkVRGN7Bg7/+cTsLpnTGzc6C5Pxy5iw7yqQv9rD/TJ7JahFCCCFE45OA2sIpisL4oPH8MfkPHu70MGYqM3an7WbKmil8eOhDSqtLTVaLmVrF1F6t2P7CYJ4d3gZrczXHUgq59+t9zP7hIHHZJSarRQghhBCNRwKqAMBGY8Mz3Z9h9cTVDPIdRI2+hsUnFzNu1TjWxK1Bp78xkxdfDWtzM/4xPITtLwzhgT6tUKsUNkdlM/J/O5i/8gTZxZUmq0UIIYQQpicBVdTjb+/PZ8M+4/Nhn+Nv709eZR6v7n6V6eunE5kbadJa3OwseGtSZzY9O5BRHT3Q6WH5gWQGfRDOR2GnKa2bT1UIIYQQzYsEVHFJA30HsmrCKuZ1n4e1mTXHc48zdd1U/rX7X+RWmPYuUEFutvzf9B78/nhfbmvlSIW2lk+2xDL4g3CW7EtCW2u61l0hhBBC3HwSUMVladQaHur0EH9O/pMJQRMAWB23mnGrxvHVsa8o15abtJ4eAc6seKIfX067jQAXa3JLq3h1dSSjFu5g48lMGfEvhBBCNBMSUMUVuVm78faAt1kydgkdXTpSpi3j84jPGbNyDEtOLaG6ttpktSiKwpjOXoTNG8S/J3bExcacMzllPPbTYe7+ai+HkwpMVosQQojmLSAggIULFzZ2GS2SBFRx1ULdQll2xzI+GPgB/vb+5Ffm897B9xi3ahyrYldRozNdn1CNWsWDfQMIf2Ewc4cGY6lRcSipgDu/3MMTSw6TkFtmslqEEEIIcWNJQBUNolJUjG49mlUTV/F639dxt3YnoyyD1/a8xpS1UwhLCjPppXY7Sw3PjWxL+PNDuLeHHyoFNkRmMuKj7by2JpLc0iqT1SKEEEI0FbW1teh0t+4YDQmo4ppoVBruanMX6yav47nuz+Fg4UBCUQLzwucxdd1U9qbvNWk9ng6WvHdXFzb8YyBD27lTo9Pz494kBn8QzmdbY6morjVpPUII0Vzp9Xp05eWN8mhIA8jXX3+Nt7f3RSFt4sSJzJo1i/j4eCZOnIiHhwf29vYMHTqUzZs3X/PP5aOPPqJz587Y2Njg5+fHk08+SWlp/bnEd+/ezeDBg7G2tsbJyYlRo0ZRUGDomqbT6Xj//fcJDg7GwsKCVq1a8fbbbwMQHh6OoigUFhYa9xUREYGiKCQmJgKwePFiHB0dWbt2LR06dMDCwoLk5GQOHjzIiBEjcHV1xcHBgUGDBnHkyJF6dRUWFvLYY4/h4eGBpaUlnTp14s8//6SsrAx7e3t+//33euuvXr0aGxsbSkpu3vzkZjdtz6JFsDSzZGanmdzZ5k5+OPkDP576kZN5J3k07FF6e/bm6duepotbF5PV09bTju9n9mRPfC4L1kdzIq2I/246zU/7kpg3og13dfdDrVJMVo8QQjQ3+ooKYm7r3ijHbnvkMIq19VWte/fddzN37ly2bdvGsGHDAMjPz+evv/5i/fr1lJaWMnbsWN5++200Gg3ffvstEydOJCYmhlatWjW4NpVKxSeffELr1q05c+YMTz75JC+++CJffPEFYAiUw4YNY9asWXz88ceYmZmxbds2amsNDSjz58/nm2++4X//+x8DBgwgIyOD6OjoBtVQXl7Oe++9x7fffouLiwvu7u6cOXOGGTNm8Omnn6LX6/nwww8ZO3YssbGx2NnZodPpGDNmDCUlJSxZsoSgoCBOnTqFWq3GxsaG++67j0WLFnHXXXcZj3P2vZ2dXYN/TldLAqq4IezM7ZjTbQ5T203l2xPf8kvML+zP3M+09dMY4jeEp7s9TbBTsMnq6Rfkypqn+vPH8XQ+2BhDakEFL604wXe7Epg/pj2D27qhKBJUhRCiuXJycmLMmDEsW7bMGFB///13XF1dGTJkCCqVitDQUMDQevnKK6+wYcMG1q5dy5w5cxp8vGeeecb4OiAggLfeeovHH3/cGFDff/99evToYXwP0LFjRwBKSkr4+OOP+eyzz5gxYwYAQUFBDBgwoEE1aLVavvjiC+P3Ahg6dGi9db7++mscHR3Zvn0748aNY/PmzRw4cICoqCjatGkDQGBgoHH92bNn069fPzIyMvDy8iI7O5v169dfV2vz1ZCAKm4oFysXXur1EtM7TOfLY1+yNn4t21K2EZ4Szvig8TzZ9Ul8bH1MUotKpTCxqw+jO3ny094kPt0ax+msUh5afJC+gS7MH9uOLr6OJqlFCCGaC8XKirZHDjfasRti2rRpPPLII3zxxRdYWFiwdOlS7rvvPlQqFaWlpbzxxhusW7eOjIwMampqqKioIDk5+Zpq27x5MwsWLCA6Opri4mJqamqorKykvLwca2trIiIiuPvuuy+5bVRUFFVVVcYgfa3Mzc3p0qX+VcusrCxeffVVwsPDyc7Opra2lvLycuP3jIiIwNfX1xhOL9SrVy86duzIDz/8wMsvv8ySJUvw9/dn4MCB11XrlUgfVHFTeNt685/+/2HVhFWM8B+BHj1r49cybtU43tn/jkkn+7cwUzP79kB2vDCExwYFYm6mYu+ZPCZ8tpunlx8lJd+087kKIcStTFEUVNbWjfJo6JWv8ePHo9frWbduHSkpKezcuZNp06YB8Pzzz7Nq1Sreeecdtm/fzo4dO+jcuTPV1Q2fOjExMZFx48bRpUsXVqxYweHDh/n8888BjPuz+ptw/XefgaH7AFCvD65Wq73kfi78Gc2YMYOIiAg+/vhj9uzZQ0REBC4uLldV11mzZ89m8eLFgOHy/kMPPXTTr0JKQBU3VaBjIB8N/oif7/iZvl59qdHVsDx6OWNXjuWTI59QXF1sslocrDXMH9Oebc8PZsptPigKrD2WzrAPt/OfP09RUGa6+VyFEELcfJaWlkyZMoWlS5eyfPly2rZty2233QYYBizNnDmTyZMn07lzZ9zd3Y0Djhrq8OHD6HQ6PvzwQ/r06UObNm1IT0+vt06XLl3YsmXLJbcPCQnBysrqsp+7ubkBkJGRYVwWERFxVbXt3r2bp59+mrFjx9KxY0csLCzIzT3XSNSlSxdSU1M5ffr0ZffxwAMPkJSUxCeffMKpU6eM3RBuJgmowiQ6unbk65Ff8+3Ib+ns2pmKmgq+OfENY1aM4bsT31FRU2GyWnwcrfjonq78MWcAA4Jdqa7V8d2uBAZ+sI3/2x5PpVZG/AshRHMxbdo01q1bx/fff29sPQVDKFy5ciUREREcO3aMRx555JqnZQoODkar1fLpp59y5swZfvrpJ7766qt668yfP5+DBw/y5JNPcvz4caKjo/nyyy/Jzc3F0tKSl156iRdffJEff/yR+Ph49u3bx3fffWfcv5+fH2+88QaxsbGsW7eODz/88KpqCwkJ4aeffiIqKor9+/czbdq0eq2mgwYNYuDAgdx5552EhYWRkJDAhg0b+Ouvv4zrODk5MWXKFF544QVGjhyJr6/vNf2cGqLBAXXHjh2MHz8eb29vFEVh9erVf7v+zJkzURTlosfZjsEAb7zxxkWft2vXrsFfRjR9vb16s3TsUhYOWUiQQxDF1cUsPLKQO1bewS/Rv6DVXXzJ4mbp5OPAktm9+XFWL9p52lFSWcOCDdEM+3A7K4+kotPJrVOFEOJWN3ToUJydnYmJieH+++83Lv/oo49wcnKiX79+TJw4kaFDhxpbVxsqNDSUjz76iPfee49OnTqxdOlSFixYUG+dNm3asGnTJo4dO0avXr3o27cva9aswczMMBzoX//6F8899xyvvfYa7du359577yU7OxsAjUbD8uXLiY6OpkuXLrz33nu89dZbV1Xbd999R0FBAbfddhvTp0/n6aefxt3dvd46K1asoGfPnkydOpUOHTrw4osvGmcXOOvhhx+murqaWbNmXdPPqKEUfQNnVd+wYQO7d++me/fuTJkyhVWrVjFp0qTLrl9UVERFxbnWsZqaGkJDQ5k7dy5vvPEGYAiov//+e70RYWZmZri6ul5VTcXFxTg4OFBUVIS9vX1Dvs4102q1rF+/nrFjx6LRaExyzOamVlfLuoR1fBHxBWmlaQD42vryVLenGNt6LCrFdA38tTo9q46m8eGmGDKKKgHo4GXP/LHtuD3EcGlFznnLI+e85ZFzfrHKykoSEhJo3bo1lpaWjV3OTaHT6SguLsbe3t7Y31PU99NPP/Hss8+Snp6Oubn53657ud+ZhuS1Bo/iHzNmDGPGjLnq9R0cHHBwcDC+X716NQUFBTz00EP1CzEzw9PTs6HliFuYWqVmQtAExgSM4bfTv/H18a9JLU1l/s75fB/5PU93e5pBvoNMMh2UWqVwV3dfxnXxYtHuRL7YFsepjGKmf3eAgW3ceHl0O0LcGjZ6VAghhLjVlZeXk5GRwbvvvstjjz12xXB6o5h8mqnvvvuO4cOH4+/vX295bGws3t7eWFpa0rdvXxYsWHDZiXKrqqqoqjp3C8viYsNAG61We8lRbTfD2eOY6njN3d3BdzMuYBzLYpbxw6kfiC2IZe7WuYS6hjIndA7dPUwzKbQamN2/FVO6evLl9jMsPZDCjtM57IzNYWIXT0LVcs5bEvlz3vLIOb+YVqs13D1Kp7ulb535d85eTD77PS+0dOlSnnjiiUtu6+/vz4kTJ25qfY3pvffe45133mHgwIG89NJLV/U7oNPp0Ov1aLVa1Gq1cXlD/lw1+BJ/vY0V5YqX+M+Xnp5Oq1atWLZsGffcc49x+YYNGygtLaVt27ZkZGTw5ptvkpaWRmRk5CXvUvDGG2/w5ptvXrR82bJlWF/lHSZE01WuK2dn1U72Ve1Di+GXOcQshBGWI/A28zZpLbmVsC5ZxZE8wyUftaKnl5ue4T46XJvnlS4hhKjn7BVOPz8/k7WeNTUlJSXk5ORc8jMzM7NruvNUc1ZdXU1KSgqZmZnU1NQYl5eXl3P//fdf1SV+kwbUBQsW8OGHH16x/0JhYSH+/v589NFHPPzwwxd9fqkWVD8/P3Jzc03aBzUsLIwRI0ZIP6WbJKc8h29PfsuquFXU6A2/4CNajeDJLk/ib+9/ha1vrOOpRby/MYb9iYWAoUvA+M6ePDawNcHutiatRZiO/DlveeScX6yyspKUlBQCAgKabR9UvV5PSUkJdnZ2cpfBG6CyspLExET8/Pwu6oPq6up6c/qgXiu9Xs/333/P9OnTr/gvMEdHR9q0aUNcXNwlP7ewsMDCwuKi5RqNxuR/oTTGMVsKbwdvXuv3Gg91eojPj33O+jPrCUsOY2vKViYFT+Lx0MfxtDFNv+XurV1Z8rADn/28nohqT7bH5rL6WAZrjmcwtpMXTw0JpoO3af5xJExP/py3PHLOz6mtrTXOsNNcBxCdvWzdnL+jKZ39fbnwz1FD/kyZ7Cxs376duLi4S7aIXqi0tJT4+Hi8vLxMUJlo6vzs/Xj39nf5bfxvDPYdTK2+lhWxK7hj5R18cPADCioLTFZLoD18++Bt/DFnACM7eKDXw7oTGYz9ZCezfzhIREqhyWoRQghTOBsqysvlrnvi6pz9Xbmef+Q1uAW1tLS0XstmQkICERERODs706pVK+bPn09aWho//vhjve2+++47evfuTadOnS7a5/PPP8/48ePx9/cnPT2d119/HbVazdSpU6/hK4nmqq1zWz4d9ikR2REsPLKQw1mH+fHUj6yIXcGMDjN4sOOD2GhsTFJLZ18Hvn6wB9GZxXy+LZ4/j6ezOSqbzVHZ3B7iypwhwfQOdDFJLUIIcTOp1WocHR2Nc3JaX8MtR5s6nU5HdXU1lZWV0oJ6HfR6PeXl5WRnZ+Po6FhvgFRDNTigHjp0iCFDhhjfz5s3DzDc63Xx4sVkZGSQnJxcb5uioiJWrFjBxx9/fMl9pqamMnXqVPLy8nBzc2PAgAHs27fPeGsvIc7X1b0ri0YtYnf6bj458glR+VF8cewLlkcvZ3bn2dzb7l4s1Bd3AbkZ2nna8+nUbjwzPIQvw+NZdTSNnbG57IzNpVeAM3OHBTMg2LXZ/WUuhGhZzk4DeTakNjd6vZ6KiopL3steNJyjo+N1Tx16XYOkmgqZqL/l0ul1bEraxOdHPyexOBEATxtPngh9gglBEzBT3bhu1ldzzlPyy/lqezy/HUqlutbQpynUz5G5Q4IZ1t5d/uK7xcif85ZHzvnfq62tbZZTcGm1Wnbs2MHAgQPlvF8njUZz2ZbTmzpRvxBNiUpRMTpgNMNbDWdN3Bq+PPYlmWWZvL7ndRZFLmJOtzmM8B9hsrtS+Tlb8/bkzswdGsLXO86w7EASx1IKmf3jIdp72TNnSDCjO3miVklQFULcetRq9XVdtm2q1Go1NTU1WFpaSkBtIqSjhWgWzFRm3NnmTtZNWcfzPZ7H0cKRxOJEnt/+PPf9eR+703ZjyosFng6WvDa+A7teGsoTg4OwMVcTlVHMU8uOMPJ/21l5JJWa2uY54bUQQghxvSSgimbFQm3BjI4z2DBlA0+EPoG1mTVR+VE8vvlxZm2cRUR2hEnrcbW14KXR7dj98lCeGR6CvaUZ8TllzPv1GEM/3M7yA8lU1dSatCYhhBCiqZOAKpolW3Nbnuz6JBvu3MD0DtPRqDQcyjrE9A3TmbtlLqcLTpu0Hkdrc54Z3obdLw/lpdHtcLExJzm/nPkrTzD4g3AW706gUitBVQghhAAJqKKZc7Z05sWeL7Ju8jomB09GpagITw3nrrV38fLOl0kpSTFpPXaWGp4YHMSul4byr3Ed8LC3IKOokjf+OMWA97bxf9vjKa2qufKOhBBCiGZMAqpoEbxsvfh3/3+zauIqRviPQI+edWfWMWHVBN7a9xY55Ze+x/LNYmWu5uEBrdn+whDemtQJH0crckurWLAhmgHvbeWTLbEUVTS/kbJCCCHE1ZCAKlqUQIdAPhr8ET+P+5l+3v2o0dfwS8wvjF05loWHF1JUVWTSeiw1ah7o40/4C4P54K4utHa1obBcy0dhpxnw7lY+2BhNXmmVSWsSQgghGpsEVNEidXTpyP+N+D++H/U9Xdy6UFlbyXeR3zFm5Ri+PfEt5VrT3tJPo1Zxdw8/Ns8bxCdTu9HWw46Sqho+3xbPgPe28dafp8gurjRpTUIIIURjkYAqWrSenj1ZMmYJnwz5hGDHYEqqS/j4yMeMXTmW5dHL0daa9jK7WqUwIdSbDf+4nf+b3p3OPg5UaGv5dlcCA97fxr9WR5JaIPfDFkII0bxJQBUtnqIoDGk1hN/H/847A97Bx9aHvMo83tn/DuNXj+eP+D+o1Zl2hL1KpTCqoydr5/Rn8UM96e7vRHWNjp/2JTH4g3Be/P0YibllJq1JCCGEMBUJqELUUavUjA8azx+T/uCV3q/gauVKWmka/9z1T+764y7CU8NNOtk/GMLz4Lbu/P54X5Y/0of+wS7U6PT8eiiVoR+G88zPR4nNKjFpTUIIIcTNJrc6FeICGrWG+9rdx4SgCSyLXsb3kd8TVxjHvB3z8FH7oEnSMCpwFGYq0/3xURSFvkEu9A1y4XBSAZ9vi2NrdDarI9JZHZHOmE6ePDUkmE4+DiarSQghhLhZpAVViMuw1lgzu/NsNkzZwMOdHsZSbUlabRov736ZcavGsSxqmckHUwF093fi+5k9+XPuAMZ08gRgQ2Qm4z7dxazFBzmcVGDymoQQQogbSQKqEFfgYOHAM92f4c+JfzLEYgiOFo6klaax4MACRq4YyadHPyW3ItfkdXXyceDLB7qz6dmBTOrqjUqBrdHZ3PnlHqZ9u4+98Xkm75IghBBC3AgSUIW4Ss6WzgyzGsa6iet4pfcr+Nr6UlRVxNfHv2bU76N4c++bJBQlmLyuNh52LLyvG1ueG8w9PXwxUynsjstj6jf7uPurvYTHZEtQFUIIcUuRgCpEA1mZWXFfu/v4c/KffDjoQzq7dqZaV83vp39n4uqJPL31aY5mHzV5Xa1dbXj/rlDCXxjM9D7+mJupOJRUwMxFB5nw2W42nsxEp5OgKoQQoumTgCrENVKr1IwMGMnSsUtZPHoxg30Ho0fPtpRtPLjhQR5Y/wCbkzabfIoqXydr/jOpEztfHMLsAa2x0qg5kVbEYz8dZszHO1l7LJ1aCapCCCGaMAmoQlwnRVHo7tGdT4d9ypqJa7gz5E40Kg3Hco7xbPizTFg9gV9jfqWyxrR3gvKwt+TVcR3Y9dIQnhoShK2FGTFZJTy9/CgjPtrOb4dS0NbqTFqTEEIIcTUkoApxAwU6BvJGvzfYdNcmHun8CPbm9iSXJPOfff9h5O8j+TLiSwoqTTvK3sXWghdGtWP3S0OZN6INjtYazuSW8cLvxxn8QThL9iVRVWPaVl4hhBDi70hAFeImcLVy5enbnibsrjBe7vUyPrY+FFQV8MWxLxj5+0je2vcWycXJJq3JwVrD08NC2PXSUOaPaYerrTlphRW8ujqSge9v47tdCVRUS1AVQgjR+CSgCnETWWusmdZ+Gn9O/pMPBn5AB5cOVNZW8kvML4xbNY554fM4lnPMpDXZWpjx2KAgdr00lDfGd8DT3pKs4ir+8+cpBry3lS/C4yip1Jq0JiGEEOJ8ElCFMAEzlRmjW4/m5zt+5ruR3zHAZwB69IQlhfHA+geYsWEG25K3odObrk+opUbNzP6t2f7iYBZM6YyfsxV5ZdW8/1cM/d/dyv/CTlNYXm2yeoQQQoiz5FanQpiQoij08upFL69exBbE8sPJH1iXsI4j2Uc4kn2EAPsAZnScwfig8VioLUxSk4WZmqm9WnF3d1/WHkvns21xnMkp4+MtsXy3K4EH+vgz+/bWuNqaph4hhBBCWlCFaCQhTiG8NeAtNt65kVmdZmGnsSOxOJE3977JyN9H8n/H/o+iqiKT1WOmVjHlNl/Cnh3E5/ffRjtPO0qravhqezwD3tvK/JUnOJVebLJ6hBBCtFwSUIVoZO7W7jzb/VnC7g7j+R7P42njSX5lPp9FfMaI30ewYP8CUktSTVaPWqVwRxcv1j99O9882INQXwcqtTqWH0hm7Cc7ufPLPaw+miYj/4UQQtw0ElCFaCJsNDbM6DiD9VPWs+D2BbR1aktFTQXLopdxx6o7eH7785zMPWmyelQqhREdPFj9VH9+frQPd3TxwkylcDipgGd+iaDfgq2891c0qQXlJqtJCCFEyyB9UIVoYjQqDeMCx3FH6zvYl7GPxScXsyd9DxsTN7IxcSM9PHrwUKeHGOAzAJVy8/+NqSgKfQJd6BPoQnZxJT8fTGHZ/mQyiyv5Mjyer7bHM6ydOw/08WdgiBsqlXLTaxJCCNG8SUAVoolSFIW+3n3p692XmPwYfjj5AxsSNnAo6xCHsg4R5BDEjI4zuCPwDszV5iapyd3ekqeHhfDk4CA2R2WzZF8Su+Jy2RyVzeaobFo5W/NAn1bc3d0PJxvT1CSEEKL5kUv8QtwC2jq35Z3b32HDnRuY0WEGNhob4ovieW3Pa4xeMZpvT3xr8gFVozt5smR2b7Y8N4iH+gdgZ2lGcn4576yPpveCLTz36zEiUgpNVpMQQojmQwKqELcQTxtPnu/5PGF3hTGv+zzcrd3Jqcjh4yMfM/L3kbx34D3SS9NNWlOQmy2vj+/I/n8O490pnengZU91jY4VR1KZ9PluJny2i18PpchdqoQQQlw1CahC3ILszO14qNND/DXlL94e8DbBjsGU15SzJGoJY1eO5aUdLxGVF2XSmqzNzbivVyvWPT2AlU/2Y0o3H8zVKo6nFvHi78fps2ALb/15ioTcMpPWJYQQ4tYjfVCFuIVp1BomBE1gfOB4dqfvZvHJxezP2M/6hPWsT1hPb6/ePNTxIfp590NRTDN4SVEUbmvlxG2tnHjljvb8djiVJfuSSC2o4NtdCXy7K4HbQ1yZ3sefoe3cMVPLv5OFEELUJwFViGZAURQG+AxggM8ATuWdYvHJxWxK3MT+jP3sz9hPiFMIMzvOZEzAGDRqjcnqcrG14PFBQTxyeyDbT2fz094kwk/nsDM2l52xuXg7WHJ/71bc27MVbnZypyohhBAGDW662LFjB+PHj8fb2xtFUVi9evXfrh8eHo6iKBc9MjMz6633+eefExAQgKWlJb179+bAgQMNLU0IAXRw6cD7A99n/ZT1PND+AazMrIgtiOWVXa8weuVoFkUuoqS6xKQ1qVUKQ9t5sOihXmx/fgiPDQrEyVpDelEl/910mn7vbuHp5Uc5mJiPXq83aW1CCCGangYH1LKyMkJDQ/n8888btF1MTAwZGRnGh7u7u/GzX375hXnz5vH6669z5MgRQkNDGTVqFNnZ2Q0tTwhRx9vWm5d6vUTYXWH847Z/4GrlSnZ5Nh8d/ogRv4/gw0MfklmWeeUd3WCtXKyZP6Y9e+cP46N7QunWyhFtrZ61x9K5+6u9jPl4J0v2JVFaVWPy2oQQQjQNDQ6oY8aM4a233mLy5MkN2s7d3R1PT0/jQ6U6d+iPPvqIRx55hIceeogOHTrw1VdfYW1tzffff9/Q8oQQF3CwcGB259lsvHMj/+73bwIdAinTlrH45GLGrBjDP3f+k5j8GJPXZalRM+U2X1Y92Z8/5w7gvp5+WGpURGeW8OrqSPq8s4XX1kRyOsu0rb1CCCEan8lGJ3Tt2hUvLy9GjBjB7t27jcurq6s5fPgww4cPP1eUSsXw4cPZu3evqcoTotkzV5szOWQyqyau4vNhn9PDowc1+hr+OPMHd/1xF4+HPc7e9L2Ncom9k48D797Zhf3zh/PauA4EutpQWlXDj3uTGPm/Hdz39V7WHc9AW6szeW1CCCFM76YPkvLy8uKrr76iR48eVFVV8e233zJ48GD279/PbbfdRm5uLrW1tXh4eNTbzsPDg+jo6Evus6qqiqqqKuP74uJiALRaLVqt9uZ9mfOcPY6pjicaX3M65309+tLXoy8n807yY9SPbEnZwu703exO301bp7Y82P5BhrcajkZlugFVANYamN7blwd6+bDnTD5L96ewJTqbfWfy2XcmH3c7C+7p7sM9PXzxcrC86fU0p3Muro6c85ZJzrtpNOTnq+ivo7lEURRWrVrFpEmTGrTdoEGDaNWqFT/99BPp6en4+PiwZ88e+vbta1znxRdfZPv27ezfv/+i7d944w3efPPNi5YvW7YMa2vrBn8PIVq6/Np89lTt4XD1YbQY/gJxUBzoZ9GPHhY9sFAab4R9QRXszVKxJ1uhRGuYKkuFnk7OegZ46mljr8dEM2gJIYS4DuXl5dx///0UFRVhb2//t+s2yjRTvXr1YteuXQC4urqiVqvJysqqt05WVhaenp6X3H7+/PnMmzfP+L64uBg/Pz9Gjhx5xS98o2i1WsLCwhgxYgQajWlbmUTjaO7n/AEeoLCqkN9jf+fn0z+TX5nPhsoN7KzdyV0hd3FXyF1423g3Sm3TgOoaHZujsll6IIUDiQUcz1c4ng+BrtZM7eXHlK7e2Fvd2PPS3M+5uJic85ZJzrtpnL3ifTUaJaBGRETg5eUFgLm5Od27d2fLli3GllidTseWLVuYM2fOJbe3sLDAwuLiFh2NRmPyX6zGOKZoXM35nLtp3Hii2xPM6jKLP+L/4IeTP5BYnMjiU4v54dQP9PHqw5SQKQxpNQQLtWlbVTUamHibHxNv8+N0Vgk/7U1i5ZFUzuSW8/b6GD4Ki2NSN28e6ONPR2+HG3zs5nvOxaXJOW+Z5LzfXA352TY4oJaWlhIXF2d8n5CQQEREBM7OzrRq1Yr58+eTlpbGjz/+CMDChQtp3bo1HTt2pLKykm+//ZatW7eyadMm4z7mzZvHjBkz6NGjB7169WLhwoWUlZXx0EMPNbQ8IcQNYKG24K42dzElZArbU7azNGop+zP3szdjL3sz9uJg4cAdre9gSsgU2jq3NXl9bTzs+M+kTrw0ph2rjqaxZG8SMVklLD+QwvIDKdzWypHpff0Z08kLS43a5PUJIYS4Pg0OqIcOHWLIkCHG92cvtc+YMYPFixeTkZFBcnKy8fPq6mqee+450tLSsLa2pkuXLmzevLnePu69915ycnJ47bXXyMzMpGvXrvz1118XDZwSQpiWSlExpNUQhrQaQkpJCmvi1rA6bjVZ5Vksi17GsuhldHDpwOTgyYwNHIu9uWm62Jxla2HG9D7+PNC7FQcTC/hpXxJ/RWZwJLmQI8mF/OfPKO7p4ce03q3wc5b+6UIIcau4rkFSTUVxcTEODg5X1en2RtFqtaxfv56xY8fK5YAWQs65Qa2ulr0Ze1kZu5JtKduo0Rkm1LdQWzDcfzhTgqfQw7MHKsVks9jVk11Sya8HU1i6P5mMokoAFAWGtnXngb7+DApxQ6W6ulFVcs5bHjnnLZOcd9NoSF5rlD6oQohbl1qlZoDPAAb4DKCgsoA/z/zJytiVxBXGse7MOtadWYevrS+TQyYzIWgCnjaXHux4s7jbWTJnaAiPDwpia3Q2P+1LYmdsLluis9kSnU0rZ2um9W7F3T38cLYxN2ltQgghro4EVCHENXOydGJ6h+k80P4BInMjWRm3kg0JG0gtTeXTo5/yecTn9PPux5SQKQz2HYxGbbqWCTO1ipEdPRnZ0ZMzOaUs3Z/Mb4dSSM4vZ8GGaD4MO824Ll5M7+NPVz9HFJmrSgghmgwJqEKI66YoCp3dOtPZrTMv9HiBzcmbWRm7ksNZh9mVtotdabtwtnRmXOA4JgdPJtgp2KT1BbrZ8q9xHXh+ZFv+OJbOj/sSiUwrZuWRNFYeSaOzjwPT+/gzPtQbK3MZVCWEEI1NAqoQ4oay1lgzIWgCE4ImkFScxKrYVayNX0tORQ4/nvqRH0/9SBfXLkwOmczogNHYmtuarDYrczX39PTj7h6+HEst4qe9SfxxPJ0TaUW8uOI4b607xd11g6oC3UxXlxBCiPokoAohbhp/e3+e6f4Mc7rNYXfablbGrmRH6g6O5x7neO5x3j/4PiP8RzAlZAq3ud9mssvsiqLQ1c+Rrn6OvHpHe347nMKSfckk55fz3a4EvtuVwO0hrkzt4UvtLT+MVAghbj0SUIUQN52ZyoxBfoMY5DeI3Ipc/oj/g5WxK0ksTmRt/FrWxq8lwD6AScGTmBg8EVcrV5PV5mRjzqMDg5g9IJDtsTks2ZvE1phsdsbmsjM2FwdzNSfVMUy+zY+O3vbSV1UIIUxAAqoQwqRcrVx5qNNDzOw4k2M5x1gZu5K/Ev8isTiRhUcW8unRT7nd93YmB0/mdt/b0ahMM7BKpVIY0tadIW3dSckvZ9mBZH4+kExBuZbvdifx3e4kAl1tmNDVmwmh3tIFQAghbiIJqEKIRqEoCl3du9LVvSsv9XqJjYkbWRm7kmM5xwhPCSc8JRwXSxcmBE9gcvBkWju0Nlltfs7WvDS6HU8Nas3CnzeSrvFmS3QOZ3LLWLg5loWbY+ns48DErt6M6+KNp4OlyWoTQoiWQAKqEKLR2WhsmBIyhSkhUzhTeIZVcYaBVXmVeSyKXMSiyEV0c+/G5ODJjAoYhbXGNHeFsjBT0dlZz0tjQ6nSKYSdymRNRDo7Y3M5kVbEibQi3l4fRe/WzkwI9WFsZ08crWVuVSGEuF4SUIUQTUqgYyDP9XiOp297mh0pO1gVt4qdaTs5mn2Uo9lHeffAu4xpPYbJIZPp4trFZH1CbS3MmNzNl8ndfMkrrWJ9ZCZrI9I4mFjAvjP57DuTz+trIxnUxo3xod6M6OCBtbn8FSuEENdC/vYUQjRJGpWGYf7DGOY/jOzybNbGr2VV7CqSS5JZEbuCFbErCHIIYnLIZMYFjsPFysVktbnYWjC9jz/T+/iTVljBH8fSWRuRzqmMYjZHZbM5KhsrjZoRHTyY2NWb20PcMDdrnFu/CiHErUgCqhCiyXO3dmd259k83OlhDmUdYnXcajYlbiK+KJ7/HvovCw8vZLDfYCaHTKa/d3/UKtNNtu/jaMXjg4J4fFAQsVklrD2Wztpj6STllRtfO1prGNPJi4ldvekV4IxKJTMBCCHE35GAKoS4ZSiKQk/PnvT07MnLvV5mQ8IGVsWuIjIvks3Jm9mcvBl3a3cmBk1kcvBk/Oz9TFpfiIcdz41sy7wRbTiWWsTaiHT+OJ5OTkkVyw8ks/xAMp72lowP9WJCqA+dfGTaKiGEuBQJqEKIW5KduR33tL2He9rew+mC06yKXcWfZ/4kuzybb058wzcnvqGnZ08mB09muP9wrMysTFbb+TcCeOWO9uw7k8faiHTWR2aQWVzJNzsT+GZngkxbJYQQlyEBVQhxy2vj1IaXer3Es92fZVvKNlbFrmJP+h4OZh7kYOZBFuxfwJjWY5gSMoUOLh1M2mqpVin0D3alf7Ar/57Uke0xOaw5ls6WqKyLpq2aEOrNuFAvvBxMF6aFEKIpkoAqhGg2zNXmjAoYxaiAUWSUZrAmfg2r41aTVprGr6d/5dfTv9LGqQ1TQqZwR+s7cLR0NGl9FmZqRnb0ZGRHT0qrai45bdU7G6LoFeDMxK4ybZUQouWSgCqEaJa8bL14PPRxHu3yKAcyD7AydiVbkrZwuuA07x54lw8PfcjQVkOZEjyFPt59UCmmHWV/qWmr/ohI50BiPvsTDI/X10YyMMSNCV1l2iohRMsif9sJIZo1laKij1cf+nj1oaiqiPUJ61kVu4qo/Cg2Jm5kY+JGvGy8mBQ8iUnBk/C29TZ5jX83bdWW6Gy2RJ+btmpCqDcD28i0VUKI5k0CqhCixXCwcGBqu6lMbTeVqLwoVsauZF3COjLKMvjy2Jd8dewrenv1ZkrIFIa2GooK04fA86etissuYW1EOmsumLbKwUrD2M5eTAj1pndrmbZKCNH8SEAVQrRI7V3a84rLKzzX4zm2JG9hVdwq9mfsZ1/GPvZl7MPe3J6xAWNxrnFGr9c3So3B7nbMG9mWZ0e04XhqEWsuM23VuC5eTOwq01YJIZoPCahCiBbN0sySOwLv4I7AO0gtSWV13GpWx60mqzyLn0//DMDaP9Yywn8Ew/yH0dm1s8n7qyqKQqifI6F101btP5PHmoh0NtRNW/XtrgS+3WWYtmp8qDcTunoTJNNWCSFuYRJQhRCijq+dL3O6zeGJ0CfYl7GPFadXsC15G6mlqSw6uYhFJxfhbu3OsFbDGOE/gm7u3TBTmfavUbVKoV+wK/3Om7Zq7bF0NtdNW/Xxllg+3hJLJx97Job6yLRVQohbkgRUIYS4gFqlpr9Pf3q592LVulXYdbZjW+o2tqduJ7s8m+XRy1kevRwnCyeGtBrC8FbD6e3VG3O1aaeEutS0VWsj0tkRm0tkWjGRacXGaasmdPVmbCcvnGxk2iohRNMnAVUIIf6GhWLB8FbDGRM0hqraKvZn7CcsKYxtKdsoqCpgZexKVsauxFZjyyC/QQxvNZz+Pv1NeucqqD9tVX5ZNetPZLD2wmmr1pxkUBvDtFXD23tgYyH/CxBCNE3yt5MQQlwlC7UFA30HMtB3IDW6Gg5lHWJz0ma2Jm8lpyKHdWfWse7MOizVlgzwGcAw/2EM8h2EnbmdSet0tjHngT7+PFA3bdWfx9JZc4lpq4Z38GCiTFslhGiCJKAKIcQ1MFOZGedX/Wfvf3I85zibkzazOXkzaaVpbE42vD673gj/EQz2G4yzpbNJ6/RxtOKxQUE8dt60VWuPpZOYV84fx9L5wzhtlScTQn1k2iohRJMgAVUIIa6TSlHR1b0rXd278lyP54jOjyYsKYwtyVs4U3SGXWm72JW2C5WioodHD4a1GsawVsPwsPEwaZ2Xmrbqz+PpZJdUsfxACssPpOBhb8H4Lt4ybZUQolFJQBVCiBtIURTau7SnvUt7nr7tac4UnjG0piZtJio/igOZBziQeYAFBxbQxa0Lw1sNZ7j/cPzs/Exa44XTVq09ls76ExlkFVcZp63ycbRiSDs3hrR1p2+Qi9xqVQhhMvK3jRBC3ESBjoE86vgoj3Z5lNSSVLYkb2Fz0mYiciI4nnOc4znH+ejwR7R1astw/+EMbzWcIMcgk7Vcnj9t1ZsTO7LjdC5rItLYHJVFWmEFS/Yls2RfMuZmKnq3dmZIW3eGtHOntauNSeoTQrRMElCFEMJEfO18mdFxBjM6ziC7PJutyVvZnLyZQ5mHiCmIIaYghs8jPifAPsAYVju4dDBZWLUwUzOigwcjOnhQUV3L3jO5bIvOYVtMNqkFFeyMzWVnbC7//vMUAS7WDG7rzuC2bvQJdMFSozZJjUKIlkECqhBCNAJ3a3fua3cf97W7j4LKAsJTwtmSvIU96XtILE7k2xPf8u2Jb/Gy8TLeGCDULRS1yjRB0MpczdB2Hgxt54Feryc+p4zwmGy2xWRzICGfxLxyFu9JZPGeRCw1KvoFuTKkrRuD27rj52xtkhqFEM2XBFQhhGhkTpZOTA6ZzOSQyZRWl7IzbSdhSWHsSttFRlkGS6KWsCRqCS6WLoYBVv7D6OnZE41KY5L6FEUh2N2WYHdbZt8eSGlVDbvjcgmPySE8JpuMokq2RmezNTobOEmQm42xK0DPAGeZwkoI0WASUIUQogmxNbdlTOsxjGk9hsqaSnan72ZL0hbCU8LJq8zj19O/8uvpX7E3t2ew32CGtxpOP59+WKgtTFejhRmjOnoyqqMner2emKwSY1eAw0kFxOeUEZ9jGGhlY66mf7ArQ9oZugPIbVeFEFdDAqoQQjRRlmaWximptLVaDmQeYHOy4cYA+ZX5rI1fy9r4tVibWXO77+0M9x/O7T63Y6Mx3QAmRVFo52lPO097nhgcRFGFlt1xuWyLzib8dA45JVVsOpXFplNZALTztGNwW3eGtHXjNn8nNGppXRVCXKzBfzPs2LGD8ePH4+3tjaIorF69+m/XX7lyJSNGjMDNzQ17e3v69u3Lxo0b663zxhtvoChKvUe7du0aWpoQQjRbGrWG/j79eb3v62y9eyuLRi1iWvtpeFh7UF5TzsbEjbyw/QUG/jyQuVvmsiZuDUVVRSav0zDpvxcf3B3K/vnD+HPuAJ4b0Ybu/k6oFIjOLOGr7fHc+/U+bvtPGE8uPcyvh1LILq40ea1CiKarwS2oZWVlhIaGMmvWLKZMmXLF9Xfs2MGIESN45513cHR0ZNGiRYwfP579+/fTrVs343odO3Zk8+bN5wozk8ZdIYS4FLVKTQ/PHvTw7MFLPV/iZN5JwpLC2Jy0meSSZMJTwwlPDcdMMaOnZ0+G+w9naKuhuFq5mrROlUqhk48DnXwcmDsshIKyanbE5hAek8P20znkl1Wz/kQm609kAtDJx54hdTMDdPVzQi13tBKixWpwChwzZgxjxoy56vUXLlxY7/0777zDmjVr+OOPP+oFVDMzMzw9PRtajhBCtGiKotDJtROdXDvxzG3PEFsYy5akLYQlhxFbEMvejL3szdjLW/veopt7N4b7D2dYq2F423qbvFYnG3MmdvVhYlcfanV6jqcWGgdaHUstIjKtmMi0Yj7dGoejtYaBIW4MaefGwBA3XGxN18dWCNH4TN5MqdPpKCkpwdm5/v2oY2Nj8fb2xtLSkr59+7JgwQJatWp1yX1UVVVRVVVlfF9cXAyAVqtFq9XevOLPc/Y4pjqeaHxyzlueW/Gct7ZtzeyOs5ndcTbJxclsTd3K1pStROZFciT7CEeyj/D+wfdp79yeYX7DGOo3lAD7gEaptZOXLZ28bJkzuDW5pVXsjM1j++lcdsblUliuZe2xdNYeS0dRoIuPA4NCXBnUxpVO3vaoblLr6q14zsX1k/NuGg35+Sp6vV5/rQdSFIVVq1YxadKkq97m/fff59133yU6Ohp3d3cANmzYQGlpKW3btiUjI4M333yTtLQ0IiMjsbOzu2gfb7zxBm+++eZFy5ctW4a1tcy/J4QQFyrUFRKljeJk9UmSapPQc+6vfneVOx00Heho3hFPlafJbgxwObV6SCqBU4UqThUopJXXr8fWTE97Jz0dHPW0c9RjLT3ChLgllJeXc//991NUVIS9vf3frmvSgLps2TIeeeQR1qxZw/Dhwy+7XmFhIf7+/nz00Uc8/PDDF31+qRZUPz8/cnNzr/iFbxStVktYWBgjRoxAozHNXISicck5b3ma6znPr8wnPDWcLSlbOJh5kBp9jfEzX1tfhvgNYZjfMDq5dEKlNP4o+6ziSnbE5rH9dA674vMoq6o1fqZSoJufI4PaGFpX23vaXVfAbq7nXPw9Oe+mUVxcjKur61UFVJP9u/Pnn39m9uzZ/Pbbb38bTgEcHR1p06YNcXFxl/zcwsICC4uL+yNpNBqT/2I1xjFF45Jz3vI0t3PuofHg3vb3cm/7eymuLmZ7ynY2J21md/puUktT+SnqJ36K+gknCyd6evakt1dv+nj1wc/Or1FaV31dNNzvYsf9fQKortFxOKnAeFer01mlHE4u5HByIR9tjsPdzoLBbd0Y0tad/iGu2Fte23lrbudcXB057zdXQ362Jgmoy5cvZ9asWfz888/ccccdV1y/tLSU+Ph4pk+fboLqhBCi5bI3t2d80HjGB42nXFvOrrRdbE7ezI7UHRRUFbApaRObkjYB4GXjRW+v3oaHZ2/crN1MXq+5mYq+QS70DXJh/tj2pBVWGMJqdA6743LJLqni10Op/HooFTOVQo8AJ+NdrULcbRu9+4IQ4uo0OKCWlpbWa9lMSEggIiICZ2dnWrVqxfz580lLS+PHH38EDJf1Z8yYwccff0zv3r3JzDRMJ2JlZYWDgwMAzz//POPHj8ff35/09HRef/111Go1U6dOvRHfUQghxFWw1lgzMmAkIwNGoq3VEpkXyb6MfezP2M+xnGNklGWwOm41q+NWAxDkEGQMrD08e2BvbpouVufzcbRiWm9/pvX2p6qmlgMJ+WyLziH8dDZncsrYdyaffWfyWbAhGh9HKwbVta72C3LBxkI6rwrRVDX4T+ehQ4cYMmSI8f28efMAmDFjBosXLyYjI4Pk5GTj519//TU1NTU89dRTPPXUU8blZ9cHSE1NZerUqeTl5eHm5saAAQPYt28fbm6m/9e5EEIIw40Burl3o5t7N54IfYJybTlHs4+yP2M/+zL2EZ0fTXxRPPFF8SyLXoZKUdHBuYMxsHZz74almaVJa7YwU3N7iBu3h7jxGh1IyisjPMZwC9a98XmkFVawbH8yy/YnY65W0TvQmcF1864GutpI66oQTUiDA+rgwYP5u3FVZ0PnWeHh4Vfc588//9zQMoQQQpiQtcaa/j796e/TH4DCykIOZh1kf8Z+9mfsJ7E4kci8SCLzIvku8jvMVeZ0de9qDKwdXTpipjJti6W/iw0z+tkwo18Aldpa9p7JIzw6m60x2aTkV7AzNpedsbn8509o5WzNkLZu3B7sTHXtlfcthLi55PqGEEKIBnO0dGSE/whG+I8AILMsk/0Z+zmQeYB9GfvILs/mQOYBDmQe4NOjn2KrsaWHRw9jYA12DDZpi6WlRm3oi9rWnTf0es7klrEtOpvwmBwOJOSTnF/OD3uT+GFvEmaKml+zD9IzwJmeAc7c1soJB2sZOCOEKUlAFUIIcd08bTyZGDyRicET0ev1JBYnGltXD2QeoLi62HgLVgBnS2d6e/Y2BlZfO1+T1aooCkFutgS52TL79kDKqmrYE5/HtphstkVnk1FUycHEAg4mFgDxKAq0cbejR4CT4eHvjK+TlXQJEOImkoAqhBDihlIUhdYOrWnt0Jr72t1Hra6W6IJoY2A9knWE/Mp8NiRuYEPiBgB8bH3o49WH3l696eXZCxcrF5PVa2NhxogOHozo4EF1dTWLV27ANiCUoylFHEoqICG3jJisEmKySli63zDGwtPeku4BTvT0d6JHgDPtvexR36S7WwnREklAFUIIcVOpVWo6unSko0tHZnWaRXVtNcdzjrM/0xBYT+ScIK00jRWxK1gRuwKAEKcQensa5l/t7tEdW3Nbk9SqKAoeVjC2uw/39wkAIKekisNJBRxKzOdQUgGRaUVkFley7ngG645nAGBjruY2f0Prao8AJ7r6OcosAUJcB/nTI4QQwqTM1eb08OxBD88ePNX1Kcq0ZRzOOmxsYY0piCG2IJbYgliWRC1Brajp5NqJXp696OPVh1D3UCzUF9+s5WZxs7NgdCdPRnfyBKCiupaIlEIOJ+VzMLGAI0kFlFTVGAddAahVCh297enu70TPAGd6+Dvhbm/aWQ2EuJVJQBVCCNGobDQ2DPQdyEDfgYDhVqwHMg8YA2tKSQrHco5xLOcY35z4Bgu1Bd3cuxnvcNXeuT1qldpk9VqZq403CwCo1ek5nVXCoURDYD2cVEBaYQXHU4s4nlrEot2JgGGmgB4B5wJrkJstKukWIMQlSUAVQgjRpDhbOjM6YDSjA0YDkF6abgirdV0Ccity2Zexj30Z+/iYj7Ezt6Onx7lbsrZ2aG3SAUxqlUJ7L3vae9kzvW+AoebCCg7VdQs4mFhAdGYxyfnlJOeXs/JIGgCO1hp6+DvR3d+ZngFOdPZ1wMLMdEFbiKZMAqoQQogmzdvWm8khk5kcMhm9Xs+ZojPGO1wdyjxESXUJW1O2sjVlKwBuVm708upl7MPqZetl+podrZjgaMWEUG8Aiiu1HE0uNPRjTSzgaEoBheVaNkdlszkqGzDcxrWLjwM9AgyBtbu/E47W5iavXYimQAKqEEKIW4aiKAQ5BhHkGMS09tOo0dUQlRfF/kzDHa4isiPIqchh3Zl1rDuzDoBWdq2M01n18uyFk6WTyeu2t9QwqI0bg9oY7pCordVxMr3YGFgPJeWTW1ptaHVNKuCr7YbtQtxt6VHXJaBngDN+zjK9lWgZJKAKIYS4ZZmpzOjs1pnObp2Z3Xk2VbVVRGRHGLsEnMw9SXJJMsklyfx2+jcA2jm3M87B2t2jO9Yaa5PXrVGr6OrnSFc/R2bfDnq9nqS8cg6eF1jjc8qIzS4lNruU5QcM01u521kY52LtGeBMey87zNQqk9cvxM0mAVUIIUSzYaG2MLaWApRUlxhnCNiXsY+4wjii86OJzo/mh1M/YKYYAm5vr9709uxNB8cOjVK3oigEuNoQ4GrD3T38AMgrNUxvdTipgIOJ+ZxIKyK7pIr1JzJZfyITAGtzNd1aORqnt+rWyglbmd5KNAPyWyyEEKLZsjO3Y7DfYAb7DQYgtyKXAxkHjAOu0krTOJp9lKPZR/nq2FdYqi3xVXxJPp5MqEcoHV06mvSmAedzsbVgZEdPRnY0TG9Vqa3leGpRXStrPoeTCiiurGF3XB674/IAUCnQwdveGFh7+Dvj6SDTW4lbjwRUIYQQLYarlStjA8cyNnAsAKklqcbprPZn7ie/Mp844oiLjINIwzbeNt50dO1IJ9dOdHbtTAeXDthobExeu6VGTa/WzvRq7QyATqcnNruUg3Vh9WBiPqkFFUSmFROZVsziPYkA+DpZGaa2qgusIe4yvZVo+iSgCiGEaLF87XzxtfPlzjZ3otfricqN4qdtP4EnnMo/RUJRAull6aSXpROWFAaAgkKgQ2C90NrGqQ3matOOuFepFNp62tHW044H+vgDkFlUyaEkQz/Wg4n5RGUUk1pQQWpBGquOGqa3src0o3vdLVp7BjjTxdcBS41MbyWaFgmoQgghBIZ+oCGOIfSx6MPYvmPRaDSUVpdyKu8UkXmRROYaHhllGcQXxRNfFM/a+LWAYbBWW6e2dHLtZHi4dKK1Q2uT3kAAwNPBknFdvBnXxTC9VWlVDUeTC4wDr44mF1JcWcO2mBy2xeQAoFErdPZxoGeAM91aOdLBy0FmCxCNTgKqEEIIcRm25rb08upFL69exmW5FbmczD1ZL7QWVhVyMu8kJ/NO8kvMLwBYm1nTwaXDudDq2glvG2+TBj9bCzNuD3Hj9hDD9FY1tTqiMkoM/VjrbtWaU1LFkeRCjiQXGrezszCru/mAHR287eng5UCIh620tAqTkYAqhBBCNICrlSuD/AYxyG8QYJgiKq00zRBYcyKJzIvkVN4pymvKOZR1iENZh4zbOls609GlY73Q6mzpbLLazdQqOvs60NnXgVkDWqPX60nJrzAG1hNpRZzOLKWkqoYDifkcSMw3bqtWKQS72dYLre297HCxtTBZ/aLlkIAqhBBCXAdFUYx9Wc/enrVWV8uZojPGFtbIvEhOF5wmvzKfnWk72Zm207i9t413vcBqykFYiqLQysWaVi7W3NndFzDcRCA+p5SojGJOpRdzqu65oFxLTFYJMVklrI5IN+7Dw96CDl729UJrgIuNDMQS10UCqhBCCHGDqVVqQpxCCHEKYXLIZACqaquIyY8hMjeSk3knOZF7gsSiROMgrE1Jm4D6g7A6u3amk2snkw7C0qhVtPO0p52nPZO7GZbp9Xqyiqs4lVFkDK1RGSUk5JaRVVxFVvG5Pq1gmJ+1naehpbW9lz0dvAz7szKXLgLi6khAFUIIIUzAQm1BF7cudHHrYlx2dhDWidwTnMw7edlBWBqVhrZObeuF1gD7AJMNwlIUBU8HSzwdLBnazuNc/VU1xGSebWkt4VRGMdEZxZRX117Ur1WlQGtXG0Ng9bY3trq628k8reJiElCFEEKIRnKlQVgnck9wMvckhVWFhj6ueZH1BmF1dO1IJ5dOxuDqZeNl8kFY3f2d6e5/rh9tTa2OxLwyQ2A9r4tAbmkV8TllxOeU8efxDOP6rrbm9UJrR297Alxs5BauLZwEVCGEEKIJudQgrNTSVENozTWE1qj8KMpryjmYeZCDmQeN254dhNXZtbNxnlZTDsICw0CsYHc7gt3tmBDqbVyeXVJJVL3QWkRCbhm5pdXsjM1lZ2yucV0LM9XFXQS87OU2ri2InGkhhBCiCVMUBT87P/zs/Bjd+m8GYeVfehCWj61PvZkDGutOWO52lrjbWTKojZtxWUV1LTFZZ0NrEVEZJUTVdRE4llrEsdSievsIcLE2BtYO3oaHp72lzNnaDElAFUIIIW4xVxqEdTa0JhQlkFaaRlppWr1BWEGOQcbQevZOWBq1xuTfw8pcTVc/R7r6ORqX6XR6kvLLOZVebJhJoK6LQGZxJYl55STmlbMhMtO4vpO15qLQGuRmi0a6CNzSJKAKIYQQzcClBmGVVJcY7oR1XmjNLMskrjCOuMI41sSvAc4Nwmrv0p4gxyCCHYMJcgzCxdLF5K2TKpVCa1cbWrvacEcXL+Py/LLqi6a+issppaBcy574PPbE5xnXNVerCPGwNYZWw00H7HGwMn0IF9dGAqoQQgjRTNmZ29Hbqze9vXobl+VW5NYLrJG5kRRVFRkHYZ3PwcKBIIcgghzPezgE4WrlavLg6mxjTv9gV/oHuxqXVWpricsuPRdaM4qJSi+mpKqGk+nFnEwvhsPn9uHrZEWHurB6dlCWr5OVSb+HuDoSUIUQQogWxNXKlcF+gxnsNxioPwgrpiCG+MJ44gvjSS1NpaiqiCPZRziSfaTePuzN7esF1rOv3azcTBpcLTVqOvk40MnHwbhMr9eTWlDBSeN8rYbW1rTCClILDI9Np7KM69tZmtHO0w7zChVZe5II8bAn0M0GXydr1HKzgUYjAVUIIYRowS41CAugsqaSxOJEY2CNL4znTNEZkkuSKa4u5mj2UY5mH623Lztzu/otrnWv3a3dTRZcFUXBz9kaP2drRnfyNC4vKteeC6x1oTU2u4SSyhoOJhYAKnZviDGub65W0crFmkBXGwLdbOueDa+drDUyMOsmk4AqhBBCiItYmlnSzrkd7Zzb1VteVVtFYlFdcC06F15TSlIoqS4hIieCiJyIetvYaewIdAy8qMXVw9rDZEHPwVpD3yAX+ga5GJdV1xhu6xqZWsCmfcdROXiSlF9BQm4ZVTU64rJLicsuBbLq78tKYwirrrZ1z4bg6u9ijaVG7pZ1I0hAFUIIIcRVs1Bb0Na5LW2d29ZbXl1bfVGLa3xRPMnFyZRoSziWc4xjOcfqbWOrsTUE1/NCa7BjsMmCq7mZivZe9gS7WmGeHsHYsV3RaDTodHrSCg1B9UxOKWdyy+pel5FWWEFRhZajyYUcPe9OWQCKAj6OVvVbXF1tae1mg5e9JSrpMnDVJKAKIYQQ4rqZq81p49SGNk5t6i2vrq0mqTjpohbX5OJkSrWlHM85zvGc4/W2sdHYEOQQRKBjIMGOwQQ6GJ49bTxNElxVqnPdBAaeN28rGOZuTcwzhNUzOaUk5JYRXxdkSyprjP1cd5zOqbedpUZFa9fzuwrYGN672WBvKbMLXEgCqhBCCCFuGnO1uXHO1vNpa7UkFScRVxTHmcIzxuCaVJxEmbaM47nHOZ5bP7ham1kT5BhkDKxnA6ynjScqxTTznlqZq43TVp1Pr9eTV1ZdP7jmlHEmt5TkvHIqtTqi6vrAXsjV1uKSwbWVs3WLnc9VAqoQQgghTE6j1hDsFEywU3C95VqdluTi5HrdBOIL40ksTqS8ppwTuSc4kXui3jZWZlbGFtez3QQCHQLxtvU2WXBVFAVXWwtcbS3o1br+7WVranWkFFSQkFvKmRxDcD37OrukitxSw+NAYn697dQqhVbO1sbweja4BrrZ4GZr0awHajU4oO7YsYMPPviAw4cPk5GRwapVq5g0adLfbhMeHs68efM4efIkfn5+vPrqq8ycObPeOp9//jkffPABmZmZhIaG8umnn9KrV6+GlieEEEKIW5hGpTH2Rz2fVqclpTiF+KJ44goNra5xhXEkFidSUVNxyXlcrcysaO3Qul43gUDHQHxsfUwWXAHM1CrjzQeG1h9zRkmlloS6Pq7x57W+JuSWUV5da3y9Jbr+dnYWZrSuG6B1fnBt7WqDtfmt3/7Y4G9QVlZGaGgos2bNYsqUKVdcPyEhgTvuuIPHH3+cpUuXsmXLFmbPno2XlxejRo0C4JdffmHevHl89dVX9O7dm4ULFzJq1ChiYmJwd3dv+LcSQgghRLOiUWkIdAwk0DGQEf4jjMtrdDUklyQbA+uZwjPEFcWRWGQIrqfyTnEq71S9fVmqLc8FV8dAAmwDyKnNobq2Go3GtP1B7Sw1dPF1pIuvY73ler2ezOJKEnLO9XE9O1ArtaCckqoajqcWcTy16KJ9ejlYGsPquZkGbPFxsrpl5nZV9Hq9/po3VpQrtqC+9NJLrFu3jsjIc/+que+++ygsLOSvv/4CoHfv3vTs2ZPPPvsMAJ1Oh5+fH3PnzuXll1++Yh3FxcU4ODhQVFSEvb39Fde/EbRaLevXr2fs2LEm/2UWjUPOecsj57zlkXPefNToakgpSTEG17NdBRKKEtDqtJfcRkHBw8YDX1tf49ywZx++dr44WDhccjtTq6qpJTmv3NjHNSGnjDN1Ibag/NLfDQyzFgS4WBuC63kzDbTxsMPOBAO1GpLXbnob8N69exk+fHi9ZaNGjeKZZ54BoLq6msOHDzN//nzj5yqViuHDh7N3796bXZ4QQgghmiEzlRmtHVrT2qE1w/yHGZfX6GpILUklvij+XHgtjCehIIFqqsksyySzLJNDWYcu2qe9ub0xrF4YYN2t3U3WbcDCTE2Ihx0hHnYXfVZQVm0Mq2dbXM/klpKYV051jY7TWaWczqo/t+u7UzpzX69WJqn9at30gJqZmYmHh0e9ZR4eHhQXF1NRUUFBQQG1tbWXXCc6+oIOF3Wqqqqoqqoyvi8uNoyI02q1aLWX/5fDjXT2OKY6nmh8cs5bHjnnLY+c85bBx9oHH2sfBnoNBAzne9OmTfQc1JPMykxSS1JJLT3vUZJKbmUuxdXFnMw7ycm8kxft01xljrett6H11dYPH1sffO188bX1xcfWBwu1hUm+m625QhdvW7p429ZbXqvTk15UQUJueV2/1rrnvHL8nS1N8jvfkGPckr1oFyxYwJtvvnnR8k2bNmFtbW3SWsLCwkx6PNH45Jy3PHLOWx455y2Poigc2nGu1dS37j8ALKHaopoCXQH5unzya/MNz3WPAl0B1TrDjQoSixMv3jcKdoodzipnnNXOOKuccVG54KRywlnljLXKtNnFDXBTQy8PwAOyT+5l/cWZ+4YrLy+/6nVvekD19PQkK6v+LcKysrKwt7fHysoKtVqNWq2+5Dqenp5cyvz585k3b57xfXFxMX5+fowcOdKkfVDDwsIYMWKE9FNqIeSctzxyzlseOect0/We9xpdDVnlWfVaXM9/XVZTRrG+mOLaYhJrEy/a3k5jZ2xtPdv/9WzLq4e1h0lnHLiZzl7xvho3PaD27duX9evX11sWFhZG3759ATA3N6d79+5s2bLFONhKp9OxZcsW5syZc8l9WlhYYGFxcVO5RqMx+V8ojXFM0bjknLc8cs5bHjnnLdO1nncNGgIsAghwCrjoM71eT0FVASklKaSUpJBaklrvOacihxJtCVH5UUTlR128b5UGH1ufi/q8+tn54WNnuq4DN0JDfrYNDqilpaXExcUZ3yckJBAREYGzszOtWrVi/vz5pKWl8eOPPwLw+OOP89lnn/Hiiy8ya9Ystm7dyq+//sq6deuM+5g3bx4zZsygR48e9OrVi4ULF1JWVsZDDz3U0PKEEEIIIZoMRVFwtnTG2dKZULfQiz6vqKkwhlVjiK1reU0rTUOr01626wCAu7X7JcOrn51fk5l14Fo0OKAeOnSIIUOGGN+fvdQ+Y8YMFi9eTEZGBsnJycbPW7duzbp163j22Wf5+OOP8fX15dtvvzXOgQpw7733kpOTw2uvvUZmZiZdu3blr7/+umjglBBCCCFEc2JlZnXJW8EC1OpqySzPrB9eS1KNgbZUW0p2eTbZ5dkczjp80fZ25naXnDLr7KwDapXaFF/xmjQ4oA4ePJi/mzp18eLFl9zm6NGjf7vfOXPmXPaSvhBCCCFES6NWqfGx9cHH1oc+Xn3qfabX6ymsKqwXXi/qOlB95a4Dvna+zOg446L9N7ZbchS/EEIIIURLpigKTpZOOFk60cWty0WfV9RUkFaSVj/AlqZcsuvAXSF3NcI3+HsSUIUQQgghmhkrMyuCnYIJdgq+6LNaXS1Z5VnG4NrJtVMjVPj3JKAKIYQQQrQgapUab1tvvG296e3Vu7HLuaTmMbGWEEIIIYRoNiSgCiGEEEKIJkUCqhBCCCGEaFIkoAohhBBCiCZFAqoQQgghhGhSJKAKIYQQQogmRQKqEEIIIYRoUiSgCiGEEEKIJkUCqhBCCCGEaFIkoAohhBBCiCZFAqoQQgghhGhSJKAKIYQQQogmRQKqEEIIIYRoUiSgCiGEEEKIJkUCqhBCCCGEaFIkoAohhBBCiCZFAqoQQgghhGhSJKAKIYQQQogmRQKqEEIIIYRoUiSgCiGEEEKIJkUCqhBCCCGEaFIkoAohhBBCiCZFAqoQQgghhGhSJKAKIYQQQogmRQKqEEIIIYRoUiSgCiGEEEKIJkUCqhBCCCGEaFIkoAohhBBCiCZFAqoQQgghhGhSJKAKIYQQQogmRQKqEEIIIYRoUq4poH7++ecEBARgaWlJ7969OXDgwGXXHTx4MIqiXPS44447jOvMnDnzos9Hjx59LaUJIYQQQohbnFlDN/jll1+YN28eX331Fb1792bhwoWMGjWKmJgY3N3dL1p/5cqVVFdXG9/n5eURGhrK3XffXW+90aNHs2jRIuN7CwuLhpYmhBBCCCGagQa3oH700Uc88sgjPPTQQ3To0IGvvvoKa2trvv/++0uu7+zsjKenp/ERFhaGtbX1RQHVwsKi3npOTk7X9o2EEEIIIcQtrUEtqNXV1Rw+fJj58+cbl6lUKoYPH87evXuvah/fffcd9913HzY2NvWWh4eH4+7ujpOTE0OHDuWtt97CxcXlkvuoqqqiqqrK+L64uBgArVaLVqttyFe6ZmePY6rjicYn57zlkXPe8sg5b5nkvJtGQ36+DQqoubm51NbW4uHhUW+5h4cH0dHRV9z+wIEDREZG8t1339VbPnr0aKZMmULr1q2Jj4/nn//8J2PGjGHv3r2o1eqL9rNgwQLefPPNi5Zv2rQJa2vrhnyl6xYWFmbS44nGJ+e85ZFz3vLIOW+Z5LzfXOXl5Ve9boP7oF6P7777js6dO9OrV696y++77z7j686dO9OlSxeCgoIIDw9n2LBhF+1n/vz5zJs3z/i+uLgYPz8/Ro4cib29/c37AufRarWEhYUxYsQINBqNSY4pGpec85ZHznnLI+e8ZZLzbhpnr3hfjQYFVFdXV9RqNVlZWfWWZ2Vl4enp+bfblpWV8fPPP/Pvf//7iscJDAzE1dWVuLi4SwZUCwuLSw6i0mg0Jv/FaoxjisYl57zlkXPe8sg5b5nkvN9cDfnZNmiQlLm5Od27d2fLli3GZTqdji1bttC3b9+/3fa3336jqqqKBx544IrHSU1NJS8vDy8vr4aUJ4QQQgghmoEGj+KfN28e33zzDT/88ANRUVE88cQTlJWV8dBDDwHw4IMP1htEddZ3333HpEmTLhr4VFpaygsvvMC+fftITExky5YtTJw4keDgYEaNGnWNX0sIIYQQQtyqGtwH9d577yUnJ4fXXnuNzMxMunbtyl9//WUcOJWcnIxKVT/3xsTEsGvXLjZt2nTR/tRqNcePH+eHH36gsLAQb29vRo4cyX/+8x+ZC1UIIYQQogW6pkFSc+bMYc6cOZf8LDw8/KJlbdu2Ra/XX3J9KysrNm7ceC1lCCGEEELc8vQ6HfqaGtBq0dfUnHtoa6Cmblltbf33dZ/r695zuWXaum1rtOfeG49hWOZ4331YdezY2D+Gekw6il8IIYQQwhT0NTXoq6rQVVWhr6xEV1mFvrr+a11lJfqqKmrKy3E4GkFhQQEqnb5eeLtUoNPX1P79OvXeX7CstvaiMIpO16g/K5v+/SWgCiGEEKLl0Ov1oNWeC4pVVYbgWBcOz39teK5GX1UXIisr64Jk1bllVVXoqirRG1+f3W/dtnXHoKamQXV6ALk350dwbdRqFDM1St3zufcq4wO1gqJSUOqeUUBRg6KAogJFpQdFj6LSoyh6FEWHouhAqTW8phZFqcXCsqCxv+1FJKAKIYQQzZRerz/v0q/2gsf5y6oNz9XauiB4QVCsqguW1xAU9VVVjd5CqGg0KBYWKJaWqOqeFQtzVBaWKBYWYKYmJz8XDy9PVGZ1AVCFIfSpzg99ehQVgK4u9OlQ0IFKbwx7CoYHSi0KNYb3ei0KWqDG8FqvRdFXoei1oKtG0dc9dFWGAKkyHM9kXJvemB8JqEIIIcRVMga+s5dnLxv6qust54oBse5RU/89f7vupben+oJ9NDGKpYUhJJprUMzNUVmYo5iboWjMUJ191qhQNGoUM5XhtRpDcDQDRa1HZWYIiyq1DkWlQ1HrUKl0KEoNKlUtiqJFUdWgQotCtSEI1lRBbUHdcxXU1i3T1wLg79vAL3J+5q693h9K3ePCuZVUZqC2ADNzMLMEtTmYWVxmWd2z8fOrXWYOHp2v8wvceBJQhRBCNGn62lrDpeDqanRV1YbwV/fe0HJXbXhdfXads5+dW25Ypj23XXUVuvPXqapCV23Yl39+PkmffV4vANKEA1+DmZkZLhVrzOpfMjZT1QVC9XmvVShmSl1AVAzhUK2ve64LhyqdIRTWBUOVUoOiqnvWVxuWUYVCVV2r43XWrwdu0mnQo6BcLtCp6wKhmfkFn52/7OzzpZZdEAqvuMwcVBff7r2lkIAqhBDikvS1tXVh7rzQV119XlisC33V54fF84Kg9hJhsS4I1guLVVXotPXX0VdX1wXIKqi93uaphrGgYflH0WhAozFcRj7/YWZ23mv1xWFQbeg7iFoxXD5Wn+s3aLx8rNIZ+w0aLiHX1F0+rqm7fGy4dKzotSi66rrWwmrD5WNdFYq+0nhZ2tAf0cSXjv+Ooro4mBnDoOYyAbHu+VLLzgY9tebiZfXC4sXBUatX2BC2lTFjx6MxN2/sn4xAAqoQQjRp9QaYVJ3X1+/CASVVVfVfG0cp12133ut6fQSrq+q/PrtOdTU0xdZClQrFwgKVubmhT+F5zypz83rvFQtzVOb111HMzesuFRtaBRU1qFR642VinU7LmTMxBIe0xkylrwuEZx/VKPoaQ/hDi6KvBl0VSk2l4VKx8bmo7vV5y282BbiaxjYzy7oWOqu6Z8tzzxrLGxAUzwt+xqB4YUCs219Tah3UatErZk0ovQsJqEIIcRX0Op2hda+y0nBJuersqOO6qWvOe33F4HheyKz/um7fZ0c01x2Py8wjbVJ1wfBqg6ChX6E5ivl56xhD4vnbXSI8qmoNrX7UoqhqUJRaVEq1IRTqqkFbDtXlhmdtRd1z3evqMtAW1C0vO/d5dd3n5eUYrhFfXjeA0zfrB6mcC4WaC0PiZULj+e/NLvH+iuvUHUttLgFM3DIkoAohWhxdZSW1+fnU5OVTW1D3nJ9PTX4etfkF557z8gjKzyfu1X81mdZE40hkc/NzI5HNLx6VrLK0MARBS8u6sHje6/PXsTCsZ3xtUTeA5ezrswHSzMwwqKReEKy4fBA0hsZyQ2C8MFAWl196G70JL+erzQ3BTWNT92yNTmNFXmEpLp6+qMytLh34LhsIr2IdtUZCohBXQQKqEOKWp6uurguchmBZm59HjfE5n9q8fGoKDM+1+fnoysuvet+XvAipUp2brubCQHf2db0wWNd6ePa1pWVdYLSov/zCdS7Yt2JujtKQcKOrhepSqCqBqrPPxXXPJVCVbvi8vBgKSs5bXrd+del5IbQcdCYM6SoNaKzrgqMVmNuce31eoMTc+txr47P1BdtYX/B53bP64v8F1mq17Fm/nrFjx6LSaEz3fYUQ9UhAFUI0OfrqamoKCs8FzLrHxS2edYGztLThB9FoMHN2Ru3sfPGzi+EZe3t2RkQweORIzG1tDS2NFuaGQTE3i15v6LdoDJO5UFpyXtAsrh8iL1p23rrV1/BzuRqKyhASzS8RCi8Kh1cKlOetd36gVEs4FKIlk4AqhLjp9DU11BYUXL5V82zozMujpqAAXXFxww9iZoaZk9O5gOnkjNrlwvDpgpmzE2oXF1S2tldsjdRqtWjT0tB4eWF2pVBar7Wy5ILgWHrxsr9b90a3VKo0YGkPFnZgbmd4vtLD3NbwuFTYlMvUQoibTAKqEKLB9LW11BYWXlU/ztq8PGqLihp+EJXKECydDIHSzNkJtbMLamcnzM4+u7igdjIEUpW9fcMuf1+KthLKsqE0B8qyUYoyCM7ai2rbUagpuyBQXvDQll3fsS+lXpi0Pe+1ff0geeEy4/p1y8ya3l1ihBDi70hAFUIY6SoqqMnKQpuVTU12NjXZWWizsqjJzqlr3axr8SwsbPjIckVB7eR0XsC84JK607lL62pnZ9QODiiqC2+rcg20FVCaDWU5dc/Zhmfj65xzz1X1g7QZ0BEgvQHHO7+18rItlvYXBM7zAubZwGluCzfi+wshxC1IAqoQLYC+tpaa3Lz6ofNsCM3KQptteK8rKWnQftWOjvWCptrFGbN6l9bPXVJXOzigqG/QvIfV5ReEy7MBNOuCMJpjuHTeoC9lDjbuYOuGztqV1PwKfII6oLZyOC9AXthaed5DWiuFEOK6SUAV4hZXW1pKTVZWXdDMNgTPs6EzO8fwWW7uVd+NR7G2RuPujpm7O2YeHmg8DK/VLi71LqmrHR0NUw/dKMbQeanWzaz6LZ3VDQvSqM3B1gNs3MDW/dxzvWWGUIqlo7F/Za1Wy9H16/EaORa1jOgWQgiTkYAqRBOl12qpyc09d8k9K4uanOxzrZ9ZWdRkZ1/9lEkqFWaurph5eGDm4Y7G3aN+CPUwvL+awUNXrbrsgsB5uUvtOQ0fca62qAuZ54VLG/cLltWFUUsHGdQjhBC3EAmoQpiYXq9HV1RU18/TEDIvDJ3a7Gxq8/Kuup+nys6uLnS6Y+bucV4IPRs8PTBzdbkxl9irSs+1ZJZmXXyp/fzWz4YOHDKzvCBkXtC6aetx7rWFvYROIYRopiSgCnED6aqqqMnJOXfJ/RL9PGuys9FXVV3dDjUazNxcDa2dlwidZy+/q6ytb+wXqSyCrJOQGQlZkZATDSWZhpZO7dVPcg8Ybt9obN30qN/SaVMXOs++trCT0CmEEEICqhBXS1daikVaGmU7dqDPzTuvn+e5fp+1hYVXvT+1o6PxsrrxkruHB2bubmg8DK/VTk43ZiT7Zb+UDgoSDCHUGEhPQGHy32+nsb6gdfNSLZ51D3NbCZ1CCCEaRAKqEJeh12qpOH6cst17KNu9m4oTJ/DX6ci4wnaKuXn9fp51IfT8fp5m7u6oLEw82ruqBLJO1YXRSEMYzT51+b6f9j7g0Qk8O4F7B3DwPdfiaWFr2tqFEEK0KBJQhaij1+vRJiVRuns3Zbv3UL5/P7qy+n0oa2xtsfHzM7Zwmnm4G17X9f3UeLijcnC4cYOMroVeD4VJ9VtEMyMNLaWXorYA93bg0dkQRj06gUdHsHY2bd1CCCFEHQmookWrLSykbN9+ynbvpmz3brTp9WdkVzs6YtOvHzb9+2HeqxdhR44wduxYNE1lyqHqcsiOOhdCz16qv9zcn7ae50KoZ2fDs0swqOWvAiGEEE2H/F9JtCj66moqjh0ztJLu2UvliRP1RsorGg1Wt92GTf/+2PTrh2WH9sY+oFrtDb4/ekPo9VCcVr9FNCsS8uKBS4z0V2nArd15YbTu2cbV5KULIYQQDSUBVTRrer2e6oQEYz/SsgMH0F8wb6hFSHBdK2l/rHv0uPEj4htKWwk5UedC6NnnysJLr2/jdl4I7Wy4PO/aBszMTVq2EEIIcaNIQBXNTk1BAeV791K6Zw9lu/dQk1F/WJPa2dkQSOsu3Ws8PBqnUL3eMHVTViRknjgXRvPiQH+Juz6pzAzB0xhGOxoCqV0j1S+EEELcJBJQxS1PV11NxZGjlO0xtJJWnjpV/7K9uTlW3W/Dtn9/bPr3x6Jt25s7ddOl1FRBTsx5LaInDH1Fy/Muvb6Vc/0WUc9Ohkv2cp93IYQQLYAEVHHL0ev1VMfHU7Z7N6V79lB+4CD6iop661i0aXPeZfvuqKysTFdgaXb9FtGsk5AbA7r/b+/O46Oq7v+Pv2ayTBYSDAlZQIQIEQICAQKYRK0FJKD1W1qsYrEEWuFnJVaaKgI/2VE2C3wVDUoFbRFxK9aqgBgLKkTBIPtuVVDMxpaQwGSZ+f5xdTASkcTM3Enm/Xw88njknrmZ+5mc8Hi8Offcc6ouPNdihciEmiOisVdDWJzWDhUREZ+lgCqNQtWJE5RtzjXmkW7eTFVBQY3X/aKiCE1NoVlaGiEpKQRER7u/qOpKKD5Yc0Q0f7exzWdtgprXHBGNuRqiEyHAg+FZRESkEVBAFa/ksNs5u20bZZs3c2bTJux799V43WKzEZKcbIySXpuG7aqr3Lv2qNOJ5as82heuwe/fb0HhHuOWfXVFLSdbILJ9zRHRmKuNhe41KioiIvKjFFDFKzidTuyHDrmeti//+GOc587VOMfWqROhacbDTSG9emENCnJ/YWdPwo4XIW85/kX7uRrgq++8HhhWc0Q0tqsxKhoY6v7aREREmigFVDFNVXHxNw82bTZu2xcV1Xjdv2VL1whpaEoK/lEeWsPT6YQvt8LHy2HPP6HKCMrOgBDyQxKJ7tYfv1bdjVB6WVuNioqIiDQwBVTxGMe5c5Tn5bkCqX3//hqvW4KCCOnd27X8ky0hwbNbhp47DTtfMoJp4Z7z7dFdIHkUVYm/Zsu7H3DT9Tfh5y07SYmIiDRB9QqoTzzxBPPnzyc/P5/u3bvz+OOP06dPn1rPffbZZxk1alSNNpvNxrnv3L51Op1MnTqVpUuXcurUKdLS0sjOziYhIaE+5YmXcDqd2A8cOH/bPi8Pp91e4xxb50Rj+afUVIJ79sRq8/AySk4nfJVnhNLdr0LVN6sB+AfD1b+GXiPh8t7GKKmZO0mJiIj4kDoH1BdffJGsrCyWLFlC3759WbRoEenp6Rw4cIDoH3hyOjw8nAMHDriOvz8qNm/ePB577DGee+454uPjmTx5Munp6ezdu5cgT8wzlAZTWVho3LbfvJmyzblUFxfXeN0/Jsa1/FNoyjX4R0aaU+i5Etj1EuQ9aywJ9a2WnSD599DtNgiOMKc2ERERH1fngLpgwQJGjx7tGhVdsmQJb775JsuWLWPChAm1/ozFYiE2NrbW15xOJ4sWLeKhhx7il7/8JQB///vfiYmJ4bXXXmPYsGF1LVE8yHH2LOUf5xnLP23ahP3QoRqvW4KDCenT2zVKGti+vWdv23/fV9sgbznsehUqy4w2Pxt0+RUkj4I2fTWnVERExGR1CqgVFRXk5eUxceJEV5vVamXAgAHk5ub+4M+dOXOGtm3b4nA46NmzJ4888ghdunQB4LPPPiM/P58BAwa4zm/evDl9+/YlNze31oBqt9uxf+dWcUlJCQCVlZVUeug27LfX8dT1vIXT6aRi/37KN+dSnpvL2W3bat76tliwJSYSkppCcGoqwd27Ywk8vyd8VVUti9W7m70Uy55/4vfJc1jyd7qanZEJOHpm4Oh6+/nR0ovU56t97svU575Hfe6b1O+eUZffb50CanFxMdXV1cR8b+/ymJgY9n/vgZdvdezYkWXLltGtWzdOnz7No48+SmpqKnv27OHyyy8nPz/f9R7ff89vX/u+2bNnM3369Ava3377bUJCQurykX6y9evXe/R6Zgo+fJiWb75F0LFjNdormzen/KoEyhISKO/QAUfoN0ssFRXBO++YUKmhefnntC3+D21O5uLvMOY8V1v8OXZZb76I+jnHQztCsQX+88P/uaqNL/W5GNTnvkd97pvU7+5VXl5+yee6/Sn+lJQUUlJSXMepqakkJiby1FNPMXPmzHq958SJE8nKynIdl5SU0KZNGwYOHEh4ePhPrvlSVFZWsn79em688UYCmvgT3faDBzm+YCHlmzYBYAkOIrhPH0JSUo1dm+LbmXvb/rsqyrDsXY1123NYv/7E1exs0R5HjxE4ug0jNiSS2iecXJwv9bkY1Oe+R33um9TvnvHtHe9LUaeAGhUVhZ+fHwXf22ayoKDgB+eYfl9AQAA9evTg8OHDAK6fKygoIC4ursZ7JiUl1foeNpsNWy1PewcEBHj8D8uMa3pKZUEBRY89xunVr4HDAf7+RAwbRtQ9f8S/RQuzy6spf7cxt3TnS2D/5h+ANQASb4HkUVjaXYefxYJfA1yqKfe51E597nvU575J/e5edfnd1imgBgYG0qtXL3JychgyZAgADoeDnJwcMjMzL+k9qqur2bVrFzfddBMA8fHxxMbGkpOT4wqkJSUlfPTRR/zxj3+sS3nSQKrPlHH8mb9xYvmzrt2cwtLTif7zOALbtTO3uO+qKIc9q41g+uXW8+0R8cbyUEnDoVlL08oTERGR+qnzLf6srCwyMjJITk6mT58+LFq0iLKyMtdT/SNGjKB169bMnj0bgBkzZnDNNdfQoUMHTp06xfz58/niiy+46667AOMJ/3HjxjFr1iwSEhJcy0y1atXKFYLFM5yVlZx8+WWKFz9B9YkTAAT36EH0+AcI6dHD5Oq+o2CvsTzUjlVgP220Wf2h083QaxTE/wysVlNLFBERkfqrc0C9/fbbKSoqYsqUKeTn55OUlMTatWtdDzkdOXIE63fCwcmTJxk9ejT5+flERETQq1cvNm/eTOfOnV3njB8/nrKyMsaMGcOpU6e49tprWbt2rdZA9RCn08mZnBwK/7qAis8+AyCwbVta/iWLsBtv9I75pZVnYc9rxmjp0Y/Ot1/WFnplQNKdEBbzgz8uIiIijUe9HpLKzMz8wVv6GzZsqHG8cOFCFi5ceNH3s1gszJgxgxkzZtSnHPkJzu7YQcG8+ZzNywPALyKCqMyxRNx2GxZvmIdTdMDY5WnHC3DulNFm8YOOg411S6/sp9FSERGRJsbtT/GLd6o4coTChQspXbMWAIvNRouRI4kcfRd+zZqZW1zlOdj3uhFMj2w+3968DfTMgB53QnjcD/+8iIiINGoKqD6m6uRJirOzOfnCKmOBfYuF5kOG0PK+PxFwiSsxuE3xIWNu6faVcNaYA4vFCld9M1ravh9YG+I5fBEREfFmCqg+wmG3c/If/6D4qadxlJYCEHrttUQ/cD9BHTuaV1iVHfb92wimn79/vj28tTFa2vN3EN7KtPJERETE8xRQmzinw0HJG29QuGgRVce+BsDWqRPRD9xPs7Q08wo7/uk3o6XPQ/lxo81ihYSBxpP4CTdqtFRERMRHKaA2YWW5uRTMn4997z4A/GNjaXnffTT/n1uw+JkQ/qoq4MCbxtzSzzaebw+Lg54joMfv4LI2nq9LREREvIoCahN07uBBCh99lLL3jFvm1tBQIseMoUXGCKxmLN114jPY9hx8sgLKir5ptECHAcbc0oR08NOfooiIiBiUCpqQyoJCih5/jNP/XG3+1qTVlXDgLeM2/qfvnm9vFmOMlPYcARFtPVuTiIiINAoKqE1A9ZkyTix7huPLn8V59iwAYQMHEp31Z89vTXryi/OjpWcKzre372fMLe04GPy8YH1VERER8VoKqI2Ys7KSU6+8QtHiJ6g+bjxoZMrWpNVVcHCtscvT4RzAabSHtjTWLO2ZAS3iPVePiIiINGoKqI2Q0+nkzLvvUvjoX83dmvTUUdj2d/jkH1D69fn2+J8Zc0s73gz+gZ6pRURERJoMBdRG5uyOHRTMn8/Zj7+zNenYsUTc7qGtSR3VcOht40n8w+vB6TDaQyIhaTj0GgmR7d1fh4iIiDRZCqiNRMXRoxQuWHDh1qR3/QG/sDDPFPHfjbB2AhTuPd/W7jojlCbeAv42z9QhIiIiTZoCqperOnmS40uWcGLlC+ZtTXriM3j7Idj/hnEc1Nx4Er/XKIjq4JkaRERExGcooHqpH9ya9P6/ENSpk2eKsJ+BDxbA5sVQbQeLH/S+C26YACEeXrZKREREfIYCqpfxiq1JHQ7Y9TK8M/X8w09X3gCD5kB0omdqEBEREZ+lgOpFyj78kMJ58zm315jjacrWpF/mwdoH4cutxnFEO0h/BDreBJ5aHUBERER8mgKqF/CKrUlL8yFnBmx/3jgOCIXr74dr7oEAE7ZHFREREZ+lgGoir9iatMoOH2bDe/Oh4ozR1v0O6D8VwuM8U4OIiIjIdyigmsArtiZ1Oo3dn9ZNghP/Ndpa94JBc6FNb8/UICIiIlILBVQPclZVGVuTPr74/NakSUlEjx9PSE8Pbk1auB/WTYRP3zWOm8XAgOnQ7XawWj1Xh4iIiEgtFFA9oLatSQPaXkF01l8IG+jBrUnPnoQNc2HL0+CsBr9ASBkL1/0FbB5a7F9ERETkRyigutnZnTspmDfPvK1JwdieNO9ZeHcWnD1htHW8GdJnQYsrPVODiIiIyCVSQHWTiqNHKVq4kJK31gDfbE2akUHk6Ls8tzUpwOcfwJoJULDLOG7ZCQbNhvb9PFeDiIiISB0ooDYwr9iaFODUEXh7Mux9zTgOag4///+Q/AfwU7eLiIiI91JSaSAOu52TK1ZQvOSp81uTpqUR/cD9ntuaFKCiDDb9r/FVdQ4sVug1yginoZGeq0NERESknhRQfyKnw8Hpf/+booWLqDx2DABbx45EP/AAza710NakYCwbtftVWD8FSr4y2tpdZ2xPGnu15+oQERER+YkUUH+C4MOH+XLYHdj37QNM2poU4Nh2WPMgHP3QOG5+hfEAVOL/aHtSERERaXQUUOvBfugQ+fPm0+b997Fj0takAGeK4N0ZsO0fgBMCQuDaLEjNhIBgz9UhIiIi0oAUUOuh9J13KH//fZxWK5cNG0Z05ljPbU0KUFUBW56CjfPAXmK0df2Nsdh+89aeq0NERETEDRRQ66FFRgb2L79kx5VXcuOIEfh7aj1TgINvG7tAHT9sHMclweC5cMU1nqtBRERExI0UUOvBGhJC9LRpVL71lucuWnwI1k2CQ28bx6Etof9USBqu7UlFRESkSVFA9XbnThu38j9aAo4qsAbANXfD9eMhKNzs6kREREQanAKqt3JUwycrIGcGlBcbbVcNgoEPQ1QHc2sTERERcSMFVG/0RS6sfRC+3mEcRyYY65kmDDC3LhEREREPqNfkxSeeeIJ27doRFBRE37592bJlyw+eu3TpUq677joiIiKIiIhgwIABF5w/cuRILBZLja9BgwbVp7TG7fSX8MofYPkgI5zamkP6I3BPrsKpiIiI+Iw6B9QXX3yRrKwspk6dyrZt2+jevTvp6ekUFhbWev6GDRu44447+M9//kNubi5t2rRh4MCBfPXVVzXOGzRoEF9//bXr64UXXqjfJ2qMKs/ChrnweDLsfgWwQK+RcG8epIwFPw+uEiAiIiJisjrf4l+wYAGjR49m1KhRACxZsoQ333yTZcuWMWHChAvOf/7552sc/+1vf+PVV18lJyeHESNGuNptNhuxsbF1Ladxczph72vw9hQ4fcRouyIVBs+BuO6mliYiIiJiljoF1IqKCvLy8pg4caKrzWq1MmDAAHJzcy/pPcrLy6msrKTF9xa237BhA9HR0URERNCvXz9mzZpFZGRkre9ht9ux2+2u45ISY7H6yspKKisr6/KR6u3b69T7egW78Xt7EtYjmwFwhremuv80nIlDjO1JPfQ55NL95D6XRkd97nvU575J/e4Zdfn9WpxOp/NSTz527BitW7dm8+bNpKSkuNrHjx/Pxo0b+eijj370Pe655x7WrVvHnj17CPpmW9BVq1YREhJCfHw8n376KZMmTaJZs2bk5ubiV8ue9tOmTWP69OkXtK9cuZKQkJBL/TimCKwqpdOxV2h3fAMWnFRZAjkcczOHY26i2mozuzwRERERtygvL+e3v/0tp0+fJjz84ktlevQp/jlz5rBq1So2bNjgCqcAw4YNc33ftWtXunXrRvv27dmwYQP9+/e/4H0mTpxIVlaW67ikpMQ1t/XHPnBDqaysZP369dx4440EXMpOUtWVWPOWYX1/HpZzpwFwdB6Cs9802je/nPbuLVcaQJ37XBo99bnvUZ/7JvW7Z3x7x/tS1CmgRkVF4efnR0FBQY32goKCH50/+uijjzJnzhzeeecdunXrdtFzr7zySqKiojh8+HCtAdVms2GzXTjaGBAQ4PE/rEu65uEcWDsRig8Yx7FdYfA8rG1T67eMgpjKjL8zMZf63Peoz32T+t296vK7rVM+CgwMpFevXuTk5LjaHA4HOTk5NW75f9+8efOYOXMma9euJTk5+Uev8+WXX3L8+HHi4uLqUp73Of4pvHAHrPi1EU5DIuGW/4UxG6FtqtnViYiIiHilOt/iz8rKIiMjg+TkZPr06cOiRYsoKytzPdU/YsQIWrduzezZswGYO3cuU6ZMYeXKlbRr1478/HwAmjVrRrNmzThz5gzTp09n6NChxMbG8umnnzJ+/Hg6dOhAenp6A35UD7KXwnvzIfdJcFSC1R/6/D/42XgIvszs6kRERES8Wp0D6u23305RURFTpkwhPz+fpKQk1q5dS0xMDABHjhzBaj0/MJudnU1FRQW33nprjfeZOnUq06ZNw8/Pj507d/Lcc89x6tQpWrVqxcCBA5k5c2att/G9msMBO16AnOlw5ptpEB0GQPpsaHmVubWJiIiINBL1ekgqMzOTzMzMWl/bsGFDjePPP//8ou8VHBzMunXr6lOGdzm6FdaMh2PbjOMW7WHQbEgYaCwbJSIiIiKXxKNP8TdJpV/Dhlmw80XjODDMuJXf927wDzS3NhEREZFGSAG1vqrOkZD/Ov7Zf4TKMsACPYZD/6nQLNrs6kREREQaLQXU+jj4Nv5v3U/nU18Yx236wqA50LqnuXWJiIiINAEKqPVR+jWWU19wNiCCgJtm4580TPNMRURERBqIAmp99LiTansZOflRpF/9K4VTERERkQakjYzqw+qHo/doqv0a2TJYIiIiIo2AAqqIiIiIeBUFVBERERHxKgqoIiIiIuJVFFBFRERExKsooIqIiIiIV1FAFRERERGvooAqIiIiIl5FAVVEREREvIoCqoiIiIh4FQVUEREREfEqCqgiIiIi4lUUUEVERETEqyigioiIiIhXUUAVEREREa/ib3YBDcHpdAJQUlLisWtWVlZSXl5OSUkJAQEBHruumEd97nvU575Hfe6b1O+e8W1O+za3XUyTCKilpaUAtGnTxuRKRERERORiSktLad68+UXPsTgvJcZ6OYfDwbFjxwgLC8NisXjkmiUlJbRp04ajR48SHh7ukWuKudTnvkd97nvU575J/e4ZTqeT0tJSWrVqhdV68VmmTWIE1Wq1cvnll5ty7fDwcP0x+xj1ue9Rn/se9blvUr+734+NnH5LD0mJiIiIiFdRQBURERERr6KAWk82m42pU6dis9nMLkU8RH3ue9Tnvkd97pvU796nSTwkJSIiIiJNh0ZQRURERMSrKKCKiIiIiFdRQBURERERr6KAKiIiIiJeRQG1Hp544gnatWtHUFAQffv2ZcuWLWaXJG40e/ZsevfuTVhYGNHR0QwZMoQDBw6YXZZ4yJw5c7BYLIwbN87sUsTNvvrqK+68804iIyMJDg6ma9eufPzxx2aXJW5SXV3N5MmTiY+PJzg4mPbt2zNz5sxL2ide3E8BtY5efPFFsrKymDp1Ktu2baN79+6kp6dTWFhodmniJhs3bmTs2LF8+OGHrF+/nsrKSgYOHEhZWZnZpYmbbd26laeeeopu3bqZXYq42cmTJ0lLSyMgIIA1a9awd+9e/vrXvxIREWF2aeImc+fOJTs7m8WLF7Nv3z7mzp3LvHnzePzxx80uTdAyU3XWt29fevfuzeLFiwFwOBy0adOGe++9lwkTJphcnXhCUVER0dHRbNy4keuvv97scsRNzpw5Q8+ePXnyySeZNWsWSUlJLFq0yOyyxE0mTJjApk2beP/9980uRTzkF7/4BTExMTzzzDOutqFDhxIcHMyKFStMrExAI6h1UlFRQV5eHgMGDHC1Wa1WBgwYQG5uromViSedPn0agBYtWphcibjT2LFjufnmm2v8e5em6/XXXyc5OZnf/OY3REdH06NHD5YuXWp2WeJGqamp5OTkcPDgQQB27NjBBx98wODBg02uTAD8zS6gMSkuLqa6upqYmJga7TExMezfv9+kqsSTHA4H48aNIy0tjauvvtrscsRNVq1axbZt29i6davZpYiH/Pe//yU7O5usrCwmTZrE1q1b+dOf/kRgYCAZGRlmlyduMGHCBEpKSujUqRN+fn5UV1fz8MMPM3z4cLNLExRQRepk7Nix7N69mw8++MDsUsRNjh49yn333cf69esJCgoyuxzxEIfDQXJyMo888ggAPXr0YPfu3SxZskQBtYl66aWXeP7551m5ciVdunRh+/btjBs3jlatWqnPvYACah1ERUXh5+dHQUFBjfaCggJiY2NNqko8JTMzkzfeeIP33nuPyy+/3OxyxE3y8vIoLCykZ8+errbq6mree+89Fi9ejN1ux8/Pz8QKxR3i4uLo3LlzjbbExEReffVVkyoSd3vggQeYMGECw4YNA6Br16588cUXzJ49WwHVC2gOah0EBgbSq1cvcnJyXG0Oh4OcnBxSUlJMrEzcyel0kpmZyerVq3n33XeJj483uyRxo/79+7Nr1y62b9/u+kpOTmb48OFs375d4bSJSktLu2D5uIMHD9K2bVuTKhJ3Ky8vx2qtGYP8/PxwOBwmVSTfpRHUOsrKyiIjI4Pk5GT69OnDokWLKCsrY9SoUWaXJm4yduxYVq5cyb/+9S/CwsLIz88HoHnz5gQHB5tcnTS0sLCwC+YXh4aGEhkZqXnHTdif//xnUlNTeeSRR7jtttvYsmULTz/9NE8//bTZpYmb3HLLLTz88MNcccUVdOnShU8++YQFCxbw+9//3uzSBC0zVS+LFy9m/vz55Ofnk5SUxGOPPUbfvn3NLkvcxGKx1Nq+fPlyRo4c6dlixBQ33HCDlpnyAW+88QYTJ07k0KFDxMfHk5WVxejRo80uS9yktLSUyZMns3r1agoLC2nVqhV33HEHU6ZMITAw0OzyfJ4CqoiIiIh4Fc1BFRERERGvooAqIiIiIl5FAVVEREREvIoCqoiIiIh4FQVUEREREfEqCqgiIiIi4lUUUEVERETEqyigiog0MRaLhddee83sMkRE6k0BVUSkAY0cORKLxXLB16BBg8wuTUSk0fA3uwARkaZm0KBBLF++vEabzWYzqRoRkcZHI6giIg3MZrMRGxtb4ysiIgIwbr9nZ2czePBggoODufLKK3nllVdq/PyuXbvo168fwcHBREZGMmbMGM6cOVPjnGXLltGlSxdsNhtxcXFkZmbWeL24uJhf/epXhISEkJCQwOuvv+7eDy0i0oAUUEVEPGzy5MkMHTqUHTt2MHz4cIYNG8a+ffsAKCsrIz09nYiICLZu3crLL7/MO++8UyOAZmdnM3bsWMaMGcOuXbt4/fXX6dChQ41rTJ8+ndtuu42dO3dy0003MXz4cE6cOOHRzykiUl8Wp9PpNLsIEZGmYuTIkaxYsYKgoKAa7ZMmTWLSpElYLBbuvvtusrOzXa9dc8019OzZkyeffJKlS5fy4IMPcvToUUJDQwF46623uOWWWzh27BgxMTG0bt2aUaNGMWvWrFprsFgsPPTQQ8ycORMwQm+zZs1Ys2aN5sKKSKOgOagiIg3s5z//eY0ACtCiRQvX9ykpKTVeS0lJYfv27QDs27eP7t27u8IpQFpaGg6HgwMHDmCxWDh27Bj9+/e/aA3dunVzfR8aGkp4eDiFhYX1/UgiIh6lgCoi0sBCQ0MvuOXeUIKDgy/pvICAgBrHFosFh8PhjpJERBqc5qCKiHjYhx9+eMFxYmIiAImJiezYsYOysjLX65s2bcJqtdKxY0fCwsJo164dOTk5Hq1ZRMSTNIIqItLA7HY7+fn5Ndr8/f2JiooC4OWXXyY5OZlrr72W559/ni1btvDMM88AMHz4cKZOnUpGRgbTpk2jqKiIe++9l9/97nfExMQAMG3aNO6++26io6MZPHgwpaWlbNq0iXvvvdezH1RExE0UUEVEGtjatWuJi4ur0daxY0f2798PGE/Yr1q1invuuYe4uDheeOEFOnfuDEBISAjr1q3jvvvuo3fv3oSEhDB06FAWLFjgeq+MjAzOnTvHwoULuf/++4mKiuLWW2/13AcUEXEzPcUvIuJBFouF1atXM2TIELNLERHxWpqDKiIiIiJeRQFVRERERLyK5qCKiHiQZlWJiPw4jaCKiIiIiFdRQBURERERr6KAKiIiIiJeRQFVRERERLyKAqqIiIiIeBUFVBERERHxKgqoIiIiIuJVFFBFRERExKsooIqIiIiIV/k/IzmJlngHfN8AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "pd.DataFrame(history.history).plot(figsize=(8, 5))\n", + "plt.grid(True)\n", + "#plt.gca().set_ylim(0, 1)\n", + "plt.xlabel(\"Epoch\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the validation error is computed at the end of each epoch, whereas the training error is computed using a running mean during each epoch." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Evaluating on the test set" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can evaluate the model on the test set using `model.evaluate`." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:49.840209Z", + "iopub.status.busy": "2024-01-10T00:21:49.839827Z", + "iopub.status.idle": "2024-01-10T00:21:50.344542Z", + "shell.execute_reply": "2024-01-10T00:21:50.343973Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/313 [..............................] - ETA: 5s - loss: 1.0352 - accuracy: 0.6875" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 42/313 [===>..........................] - ETA: 0s - loss: 0.9976 - accuracy: 0.6905" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 76/313 [======>.......................] - ETA: 0s - loss: 0.9815 - accuracy: 0.7015" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "114/313 [=========>....................] - ETA: 0s - loss: 0.9998 - accuracy: 0.6913" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "154/313 [=============>................] - ETA: 0s - loss: 0.9935 - accuracy: 0.6940" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "195/313 [=================>............] - ETA: 0s - loss: 0.9921 - accuracy: 0.6934" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "234/313 [=====================>........] - ETA: 0s - loss: 0.9949 - accuracy: 0.6910" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "273/313 [=========================>....] - ETA: 0s - loss: 0.9939 - accuracy: 0.6930" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "312/313 [============================>.] - ETA: 0s - loss: 0.9923 - accuracy: 0.6925" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "313/313 [==============================] - 0s 1ms/step - loss: 0.9921 - accuracy: 0.6924\n" + ] + }, + { + "data": { + "text/plain": [ + "[0.9921249747276306, 0.6923999786376953]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.evaluate(X_test, y_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Predictions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can make predictions on new data using `model.predict`.\n", + "\n", + "Consider the first three images in the test set." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:50.347632Z", + "iopub.status.busy": "2024-01-10T00:21:50.347162Z", + "iopub.status.idle": "2024-01-10T00:21:50.350406Z", + "shell.execute_reply": "2024-01-10T00:21:50.349752Z" + } + }, + "outputs": [], + "source": [ + "X_new = X_test[:3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Estimating class probabilities:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:50.353513Z", + "iopub.status.busy": "2024-01-10T00:21:50.353076Z", + "iopub.status.idle": "2024-01-10T00:21:50.468599Z", + "shell.execute_reply": "2024-01-10T00:21:50.467984Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "1/1 [==============================] - ETA: 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1/1 [==============================] - 0s 72ms/step\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[0.01, 0.01, 0.01, 0.01, 0.01, 0.21, 0.01, 0.18, 0.11, 0.45],\n", + " [0.04, 0.01, 0.46, 0.01, 0.26, 0. , 0.2 , 0. , 0.02, 0.01],\n", + " [0.01, 0.85, 0.02, 0.09, 0.01, 0. , 0.01, 0. , 0. , 0. ]],\n", + " dtype=float32)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_proba = model.predict(X_new)\n", + "y_proba.round(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Making class predictions:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:50.472054Z", + "iopub.status.busy": "2024-01-10T00:21:50.471483Z", + "iopub.status.idle": "2024-01-10T00:21:50.522933Z", + "shell.execute_reply": "2024-01-10T00:21:50.522224Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "1/1 [==============================] - ETA: 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1/1 [==============================] - 0s 15ms/step\n" + ] + }, + { + "data": { + "text/plain": [ + "array([9, 2, 1])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_pred = np.argmax(model.predict(X_new), axis=-1)\n", + "y_pred" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:50.526022Z", + "iopub.status.busy": "2024-01-10T00:21:50.525777Z", + "iopub.status.idle": "2024-01-10T00:21:50.532206Z", + "shell.execute_reply": "2024-01-10T00:21:50.531609Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['Ankle boot', 'Pullover', 'Trouser'], dtype='" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(7.2, 2.4))\n", + "for index, image in enumerate(X_new):\n", + " plt.subplot(1, 3, index + 1)\n", + " plt.imshow(image, cmap=\"binary\", interpolation=\"nearest\")\n", + " plt.axis('off')\n", + " plt.title(class_names[y_test[index]], fontsize=12)\n", + "plt.subplots_adjust(wspace=0.2, hspace=0.5)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + }, + "tags": [ + "exercise_pointer" + ] + }, + "source": [ + "**Exercises:** *You can now complete Exercise 1 in the exercises associated with this lecture.*" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Functional API" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "While the *Sequential API* is very easy to use and many models are sequential in nature, it is also somewhat limited. \n", + "\n", + "The *Functional API* allows more complex models to be built." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "For example, a Wide & Deep neural network (see [paper](https://ai.google/research/pubs/pub45413)) connects all or part of the inputs directly to the output layer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "[Credit: Geron]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Loading data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will illustrate the use of the Functional API to build this model, using the California housing dataset as a regression problem." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:50.694318Z", + "iopub.status.busy": "2024-01-10T00:21:50.693943Z", + "iopub.status.idle": "2024-01-10T00:21:51.132364Z", + "shell.execute_reply": "2024-01-10T00:21:51.131666Z" + } + }, + "outputs": [], + "source": [ + "from sklearn.datasets import fetch_california_housing\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "housing = fetch_california_housing()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The dataset contains 8 features (displayed below) contained in `housing.data` that can be used to predict house prices (in units of $100,000), which are contained in `housing.targets`." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:51.136510Z", + "iopub.status.busy": "2024-01-10T00:21:51.135571Z", + "iopub.status.idle": "2024-01-10T00:21:51.142818Z", + "shell.execute_reply": "2024-01-10T00:21:51.142192Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['MedInc',\n", + " 'HouseAge',\n", + " 'AveRooms',\n", + " 'AveBedrms',\n", + " 'Population',\n", + " 'AveOccup',\n", + " 'Latitude',\n", + " 'Longitude']" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "housing.feature_names" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Split the data into training, validation and test sets." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:51.145823Z", + "iopub.status.busy": "2024-01-10T00:21:51.145375Z", + "iopub.status.idle": "2024-01-10T00:21:51.153365Z", + "shell.execute_reply": "2024-01-10T00:21:51.152756Z" + } + }, + "outputs": [], + "source": [ + "X_train_full, X_test, y_train_full, y_test = train_test_split(housing.data, housing.target, random_state=42)\n", + "X_train, X_valid, y_train, y_valid = train_test_split(X_train_full, y_train_full, random_state=42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Scale features to standardise." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:51.156397Z", + "iopub.status.busy": "2024-01-10T00:21:51.155849Z", + "iopub.status.idle": "2024-01-10T00:21:51.163001Z", + "shell.execute_reply": "2024-01-10T00:21:51.162377Z" + } + }, + "outputs": [], + "source": [ + "scaler = StandardScaler()\n", + "X_train = scaler.fit_transform(X_train)\n", + "X_valid = scaler.transform(X_valid)\n", + "X_test = scaler.transform(X_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Building the model" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:51.166106Z", + "iopub.status.busy": "2024-01-10T00:21:51.165656Z", + "iopub.status.idle": "2024-01-10T00:21:51.211714Z", + "shell.execute_reply": "2024-01-10T00:21:51.211062Z" + } + }, + "outputs": [], + "source": [ + "input_ = keras.layers.Input(shape=X_train.shape[1:])\n", + "hidden1 = keras.layers.Dense(30, activation=\"relu\")(input_)\n", + "hidden2 = keras.layers.Dense(30, activation=\"relu\")(hidden1)\n", + "concat = keras.layers.concatenate([input_, hidden2])\n", + "output = keras.layers.Dense(1)(concat)\n", + "model = keras.models.Model(inputs=[input_], outputs=[output])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Setting up the functional model consists of the following steps.\n", + "\n", + "1. Set up the input of the model.\n", + "2. Create a dense layer with 30 neurons that takes `_input` as the input, and includes a ReLU activation function.\n", + "3. Create a dense layer with 30 neurons that takes the output of the previous layer as an input, and includes a ReLU activation function.\n", + "4. Concatenate the input and the output of the second hidden layer.\n", + "5. Create a dense layer that takes the concatenated data as an input and outputs a single value (for the regression model).\n", + "6. Build the model specifying the inputs and outputs (of which there can be multiple)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that each component is called like a function, mapping inputs to outputs, hence the name of the *Functional API*." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:51.215342Z", + "iopub.status.busy": "2024-01-10T00:21:51.214753Z", + "iopub.status.idle": "2024-01-10T00:21:51.227654Z", + "shell.execute_reply": "2024-01-10T00:21:51.227031Z" + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model\"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "__________________________________________________________________________________________________\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Layer (type) Output Shape Param # Connected to \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==================================================================================================\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " input_1 (InputLayer) [(None, 8)] 0 [] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " dense_6 (Dense) (None, 30) 270 ['input_1[0][0]'] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " dense_7 (Dense) (None, 30) 930 ['dense_6[0][0]'] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " concatenate (Concatenate) (None, 38) 0 ['input_1[0][0]', \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 'dense_7[0][0]'] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " dense_8 (Dense) (None, 1) 39 ['concatenate[0][0]'] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==================================================================================================\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total params: 1239 (4.84 KB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trainable params: 1239 (4.84 KB)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Non-trainable params: 0 (0.00 Byte)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "__________________________________________________________________________________________________\n" + ] + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Compiling the model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once the model is created we again need to *compile* the mode to specify the loss function and the optimizer to use to train the model. " + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:51.236695Z", + "iopub.status.busy": "2024-01-10T00:21:51.236463Z", + "iopub.status.idle": "2024-01-10T00:21:51.245841Z", + "shell.execute_reply": "2024-01-10T00:21:51.245234Z" + } + }, + "outputs": [], + "source": [ + "model.compile(loss=\"mean_squared_error\", optimizer=keras.optimizers.legacy.SGD(learning_rate=1e-4))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Fitting the model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again we fit the model, given training and validation data and number of epochs, and compute the loss on the validation data at the end of each epoch." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:21:51.249013Z", + "iopub.status.busy": "2024-01-10T00:21:51.248561Z", + "iopub.status.idle": "2024-01-10T00:22:01.770841Z", + "shell.execute_reply": "2024-01-10T00:22:01.770109Z" + }, + "tags": [ + "hide-output" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1:27 - loss: 5.0352" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 59/363 [===>..........................] - ETA: 0s - loss: 4.4361 " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "116/363 [========>.....................] - ETA: 0s - loss: 4.4623" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "175/363 [=============>................] - ETA: 0s - loss: 4.2806" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "227/363 [=================>............] - ETA: 0s - loss: 4.1482" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "285/363 [======================>.......] - ETA: 0s - loss: 4.0619" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "338/363 [==========================>...] - ETA: 0s - loss: 4.0001" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 3.9669 - val_loss: 3.2366\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 2/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 2.8640" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 57/363 [===>..........................] - ETA: 0s - loss: 3.2584" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "114/363 [========>.....................] - ETA: 0s - loss: 3.1807" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "171/363 [=============>................] - ETA: 0s - loss: 3.1405" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "230/363 [==================>...........] - ETA: 0s - loss: 3.0758" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "289/363 [======================>.......] - ETA: 0s - loss: 3.0021" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "349/363 [===========================>..] - ETA: 0s - loss: 2.9106" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 2.8904 - val_loss: 2.4843\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 3/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 3.2218" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 59/363 [===>..........................] - ETA: 0s - loss: 2.4117" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "119/363 [========>.....................] - ETA: 0s - loss: 2.3231" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "179/363 [=============>................] - ETA: 0s - loss: 2.2530" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "238/363 [==================>...........] - ETA: 0s - loss: 2.2016" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "290/363 [======================>.......] - ETA: 0s - loss: 2.1544" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "350/363 [===========================>..] - ETA: 0s - loss: 2.1172" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 2.1077 - val_loss: 2.3508\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 4/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.7996" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 59/363 [===>..........................] - ETA: 0s - loss: 1.7586" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "120/363 [========>.....................] - ETA: 0s - loss: 1.7397" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "183/363 [==============>...............] - ETA: 0s - loss: 1.6909" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "244/363 [===================>..........] - ETA: 0s - loss: 1.6395" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "305/363 [========================>.....] - ETA: 0s - loss: 1.6097" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.5802 - val_loss: 2.3037\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 5/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 1.0817" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 58/363 [===>..........................] - ETA: 0s - loss: 1.2705" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "116/363 [========>.....................] - ETA: 0s - loss: 1.2872" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "178/363 [=============>................] - ETA: 0s - loss: 1.3080" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "236/363 [==================>...........] - ETA: 0s - loss: 1.3184" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "291/363 [=======================>......] - ETA: 0s - loss: 1.2866" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "351/363 [============================>.] - ETA: 0s - loss: 1.2582" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.2488 - val_loss: 2.2434\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 6/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.9887" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 59/363 [===>..........................] - ETA: 0s - loss: 1.0967" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "116/363 [========>.....................] - ETA: 0s - loss: 1.0821" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "176/363 [=============>................] - ETA: 0s - loss: 1.0856" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "236/363 [==================>...........] - ETA: 0s - loss: 1.0620" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "295/363 [=======================>......] - ETA: 0s - loss: 1.0664" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "353/363 [============================>.] - ETA: 0s - loss: 1.0502" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.0483 - val_loss: 2.0401\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 7/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.8572" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 60/363 [===>..........................] - ETA: 0s - loss: 0.9367" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "119/363 [========>.....................] - ETA: 0s - loss: 0.9612" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "177/363 [=============>................] - ETA: 0s - loss: 0.9483" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "237/363 [==================>...........] - ETA: 0s - loss: 0.9361" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "298/363 [=======================>......] - ETA: 0s - loss: 0.9425" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "355/363 [============================>.] - ETA: 0s - loss: 0.9286" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.9279 - val_loss: 1.7862\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 8/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.0893" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 56/363 [===>..........................] - ETA: 0s - loss: 0.8884" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "116/363 [========>.....................] - ETA: 0s - loss: 0.8675" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "175/363 [=============>................] - ETA: 0s - loss: 0.8943" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "233/363 [==================>...........] - ETA: 0s - loss: 0.8688" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "294/363 [=======================>......] - ETA: 0s - loss: 0.8561" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "354/363 [============================>.] - ETA: 0s - loss: 0.8519" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.8540 - val_loss: 1.5311\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 9/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.3581" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 58/363 [===>..........................] - ETA: 0s - loss: 0.8123" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "115/363 [========>.....................] - ETA: 0s - loss: 0.8187" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "172/363 [=============>................] - ETA: 0s - loss: 0.8233" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "230/363 [==================>...........] - ETA: 0s - loss: 0.8288" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "291/363 [=======================>......] - ETA: 0s - loss: 0.8183" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "353/363 [============================>.] - ETA: 0s - loss: 0.8107" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.8065 - val_loss: 1.3055\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 10/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.6485" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 58/363 [===>..........................] - ETA: 0s - loss: 0.7880" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "116/363 [========>.....................] - ETA: 0s - loss: 0.7582" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "172/363 [=============>................] - ETA: 0s - loss: 0.7635" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "225/363 [=================>............] - ETA: 0s - loss: 0.7606" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "283/363 [======================>.......] - ETA: 0s - loss: 0.7640" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "342/363 [===========================>..] - ETA: 0s - loss: 0.7726" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.7745 - val_loss: 1.1189\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 11/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.8449" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 61/363 [====>.........................] - ETA: 0s - loss: 0.7597" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "120/363 [========>.....................] - ETA: 0s - loss: 0.7654" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "181/363 [=============>................] - ETA: 0s - loss: 0.7683" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "242/363 [===================>..........] - ETA: 0s - loss: 0.7545" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "299/363 [=======================>......] - ETA: 0s - loss: 0.7466" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "355/363 [============================>.] - ETA: 0s - loss: 0.7501" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.7515 - val_loss: 0.9730\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 12/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.7637" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 58/363 [===>..........................] - ETA: 0s - loss: 0.7466" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "113/363 [========>.....................] - ETA: 0s - loss: 0.7441" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "168/363 [============>.................] - ETA: 0s - loss: 0.7316" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "222/363 [=================>............] - ETA: 0s - loss: 0.7266" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "276/363 [=====================>........] - ETA: 0s - loss: 0.7317" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "332/363 [==========================>...] - ETA: 0s - loss: 0.7322" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.7339 - val_loss: 0.8720\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 13/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.5952" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 60/363 [===>..........................] - ETA: 0s - loss: 0.6964" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "118/363 [========>.....................] - ETA: 0s - loss: 0.7134" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "178/363 [=============>................] - ETA: 0s - loss: 0.7313" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "238/363 [==================>...........] - ETA: 0s - loss: 0.7318" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "298/363 [=======================>......] - ETA: 0s - loss: 0.7211" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "359/363 [============================>.] - ETA: 0s - loss: 0.7228" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.7200 - val_loss: 0.7940\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 14/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.0001" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 59/363 [===>..........................] - ETA: 0s - loss: 0.6903" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "114/363 [========>.....................] - ETA: 0s - loss: 0.6875" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "171/363 [=============>................] - ETA: 0s - loss: 0.6806" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "230/363 [==================>...........] - ETA: 0s - loss: 0.6973" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "290/363 [======================>.......] - ETA: 0s - loss: 0.7051" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "350/363 [===========================>..] - ETA: 0s - loss: 0.7041" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.7083 - val_loss: 0.7394\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 15/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.6757" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 59/363 [===>..........................] - ETA: 0s - loss: 0.6625" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "111/363 [========>.....................] - ETA: 0s - loss: 0.6688" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "168/363 [============>.................] - ETA: 0s - loss: 0.6872" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "225/363 [=================>............] - ETA: 0s - loss: 0.6858" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "283/363 [======================>.......] - ETA: 0s - loss: 0.6934" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "341/363 [===========================>..] - ETA: 0s - loss: 0.6944" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.6983 - val_loss: 0.7027\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 16/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.2976" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 60/363 [===>..........................] - ETA: 0s - loss: 0.6761" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "118/363 [========>.....................] - ETA: 0s - loss: 0.6944" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "177/363 [=============>................] - ETA: 0s - loss: 0.6842" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "236/363 [==================>...........] - ETA: 0s - loss: 0.6842" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "293/363 [=======================>......] - ETA: 0s - loss: 0.6802" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "352/363 [============================>.] - ETA: 0s - loss: 0.6855" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.6895 - val_loss: 0.6740\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 17/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.0462" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 60/363 [===>..........................] - ETA: 0s - loss: 0.6561" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "119/363 [========>.....................] - ETA: 0s - loss: 0.6876" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "178/363 [=============>................] - ETA: 0s - loss: 0.6691" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "237/363 [==================>...........] - ETA: 0s - loss: 0.6792" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "297/363 [=======================>......] - ETA: 0s - loss: 0.6716" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "351/363 [============================>.] - ETA: 0s - loss: 0.6794" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.6814 - val_loss: 0.6559\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 18/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.8168" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 58/363 [===>..........................] - ETA: 0s - loss: 0.7141" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "115/363 [========>.....................] - ETA: 0s - loss: 0.7038" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "170/363 [=============>................] - ETA: 0s - loss: 0.6820" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "226/363 [=================>............] - ETA: 0s - loss: 0.6773" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "284/363 [======================>.......] - ETA: 0s - loss: 0.6732" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "342/363 [===========================>..] - ETA: 0s - loss: 0.6720" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.6740 - val_loss: 0.6436\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 19/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.5625" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 58/363 [===>..........................] - ETA: 0s - loss: 0.6698" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "115/363 [========>.....................] - ETA: 0s - loss: 0.6424" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "174/363 [=============>................] - ETA: 0s - loss: 0.6532" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "233/363 [==================>...........] - ETA: 0s - loss: 0.6533" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "295/363 [=======================>......] - ETA: 0s - loss: 0.6602" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "355/363 [============================>.] - ETA: 0s - loss: 0.6689" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.6671 - val_loss: 0.6339\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 20/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.3245" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 57/363 [===>..........................] - ETA: 0s - loss: 0.6900" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "118/363 [========>.....................] - ETA: 0s - loss: 0.6724" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "179/363 [=============>................] - ETA: 0s - loss: 0.6647" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "237/363 [==================>...........] - ETA: 0s - loss: 0.6587" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "296/363 [=======================>......] - ETA: 0s - loss: 0.6589" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "354/363 [============================>.] - ETA: 0s - loss: 0.6605" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.6606 - val_loss: 0.6268\n" + ] + } + ], + "source": [ + "history = model.fit(X_train, y_train, epochs=20,\n", + " validation_data=(X_valid, y_valid))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Evaluating on the test set" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We evaluate the model on the test set as before." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:01.774767Z", + "iopub.status.busy": "2024-01-10T00:22:01.774216Z", + "iopub.status.idle": "2024-01-10T00:22:01.961975Z", + "shell.execute_reply": "2024-01-10T00:22:01.961380Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/162 [..............................] - ETA: 2s - loss: 0.7559" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 64/162 [==========>...................] - ETA: 0s - loss: 0.6827" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "128/162 [======================>.......] - ETA: 0s - loss: 0.6675" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "162/162 [==============================] - 0s 815us/step - loss: 0.6546\n" + ] + } + ], + "source": [ + "mse_test = model.evaluate(X_test, y_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Predictions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We again make predictions on new data (the first three instances of the test set) using `model.predict`." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:01.965155Z", + "iopub.status.busy": "2024-01-10T00:22:01.964691Z", + "iopub.status.idle": "2024-01-10T00:22:02.052864Z", + "shell.execute_reply": "2024-01-10T00:22:02.052223Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "1/1 [==============================] - ETA: 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1/1 [==============================] - 0s 46ms/step\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[0.8628876],\n", + " [1.0634453],\n", + " [2.492951 ]], dtype=float32)" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_new = X_test[:3]\n", + "y_pred = model.predict(X_new)\n", + "y_pred" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Subclassing API" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Both the *Sequential API* and the *Functional API* support static models: they involving defining a model and then feeding it data for training or inference.\n", + "\n", + "The *Subclassing API* allows you to subclass Keras models (and other objects such as layers). This supports dynamic models and allows you to construct alternative model objects that can be widely used elsewhere." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Building the model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's use the *Subclassing API* to build a Wide & Deep neural network with two inputs and two outputs as an example." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "[Credit: Geron]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Firstly, let's spit our data so we have two sets of inputs." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:02.056626Z", + "iopub.status.busy": "2024-01-10T00:22:02.056053Z", + "iopub.status.idle": "2024-01-10T00:22:02.060389Z", + "shell.execute_reply": "2024-01-10T00:22:02.059694Z" + } + }, + "outputs": [], + "source": [ + "X_train_A, X_train_B = X_train[:, :5], X_train[:, 2:]\n", + "X_valid_A, X_valid_B = X_valid[:, :5], X_valid[:, 2:]\n", + "X_test_A, X_test_B = X_test[:, :5], X_test[:, 2:]\n", + "X_new_A, X_new_B = X_test_A[:3], X_test_B[:3]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "A model class can then be written to implement the model, inheriting from `keras.models.Model`." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:02.063644Z", + "iopub.status.busy": "2024-01-10T00:22:02.063090Z", + "iopub.status.idle": "2024-01-10T00:22:02.075512Z", + "shell.execute_reply": "2024-01-10T00:22:02.074855Z" + } + }, + "outputs": [], + "source": [ + "class WideAndDeepModel(keras.models.Model):\n", + " def __init__(self, units=30, activation=\"relu\", **kwargs):\n", + " super().__init__(**kwargs)\n", + " self.hidden1 = keras.layers.Dense(units, activation=activation)\n", + " self.hidden2 = keras.layers.Dense(units, activation=activation)\n", + " self.main_output = keras.layers.Dense(1)\n", + " self.aux_output = keras.layers.Dense(1)\n", + " \n", + " def call(self, inputs):\n", + " input_A, input_B = inputs\n", + " hidden1 = self.hidden1(input_B)\n", + " hidden2 = self.hidden2(hidden1)\n", + " concat = keras.layers.concatenate([input_A, hidden2])\n", + " main_output = self.main_output(concat)\n", + " aux_output = self.aux_output(hidden2)\n", + " return main_output, aux_output\n", + "\n", + "model = WideAndDeepModel(30, activation=\"relu\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model must have `__init__` and `call` methods. Within `__init__` you need to instantiate the layers that you need, before you make use of them within `call`.\n", + "\n", + "Since the `call` method is implemented directly, there is a great deal of flexibility to implement complex models." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "The model can then be used like other Keras model and you can compile and fit it as usual." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that for bespoke models implemented this way, Keras cannot easily inspect it. Thus, it is not so straightforward, e.g., to save the model or to perform type and shape checking. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Compiling the model" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:02.078604Z", + "iopub.status.busy": "2024-01-10T00:22:02.078361Z", + "iopub.status.idle": "2024-01-10T00:22:02.086069Z", + "shell.execute_reply": "2024-01-10T00:22:02.085470Z" + } + }, + "outputs": [], + "source": [ + "model.compile(loss=\"mse\", loss_weights=[0.9, 0.1], optimizer=keras.optimizers.legacy.SGD(learning_rate=1e-4))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Fitting the model" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:02.089290Z", + "iopub.status.busy": "2024-01-10T00:22:02.088739Z", + "iopub.status.idle": "2024-01-10T00:22:12.851433Z", + "shell.execute_reply": "2024-01-10T00:22:12.850716Z" + }, + "tags": [ + "hide-output" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 2:53 - loss: 5.9495 - output_1_loss: 6.0951 - output_2_loss: 4.6391" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/363 [===>..........................] - ETA: 0s - loss: 6.0571 - output_1_loss: 6.1273 - output_2_loss: 5.4251 " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "102/363 [=======>......................] - ETA: 0s - loss: 5.8515 - output_1_loss: 5.9350 - output_2_loss: 5.0999" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "151/363 [===========>..................] - ETA: 0s - loss: 5.6583 - output_1_loss: 5.7532 - output_2_loss: 4.8042" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "199/363 [===============>..............] - ETA: 0s - loss: 5.5574 - output_1_loss: 5.6443 - output_2_loss: 4.7752" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "250/363 [===================>..........] - ETA: 0s - loss: 5.4171 - output_1_loss: 5.4875 - output_2_loss: 4.7839" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "299/363 [=======================>......] - ETA: 0s - loss: 5.3115 - output_1_loss: 5.3816 - output_2_loss: 4.6811" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "348/363 [===========================>..] - ETA: 0s - loss: 5.2010 - output_1_loss: 5.2643 - output_2_loss: 4.6313" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 2ms/step - loss: 5.1666 - output_1_loss: 5.2294 - output_2_loss: 4.6012 - val_loss: 8.9329 - val_output_1_loss: 8.5437 - val_output_2_loss: 12.4361\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 2/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 4.9774 - output_1_loss: 5.0323 - output_2_loss: 4.4826" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 50/363 [===>..........................] - ETA: 0s - loss: 4.2478 - output_1_loss: 4.2542 - output_2_loss: 4.1908" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "101/363 [=======>......................] - ETA: 0s - loss: 4.2878 - output_1_loss: 4.2640 - output_2_loss: 4.5021" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "149/363 [===========>..................] - ETA: 0s - loss: 4.1819 - output_1_loss: 4.1161 - output_2_loss: 4.7746" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "202/363 [===============>..............] - ETA: 0s - loss: 4.0247 - output_1_loss: 3.9733 - output_2_loss: 4.4874" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "255/363 [====================>.........] - ETA: 0s - loss: 3.9606 - output_1_loss: 3.9188 - output_2_loss: 4.3373" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "307/363 [========================>.....] - ETA: 0s - loss: 3.8794 - output_1_loss: 3.8357 - output_2_loss: 4.2727" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "358/363 [============================>.] - ETA: 0s - loss: 3.8194 - output_1_loss: 3.7715 - output_2_loss: 4.2503" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 3.8165 - output_1_loss: 3.7694 - output_2_loss: 4.2401 - val_loss: 9.7437 - val_output_1_loss: 9.4373 - val_output_2_loss: 12.5014\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 3/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 1.7409 - output_1_loss: 1.7139 - output_2_loss: 1.9834" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 50/363 [===>..........................] - ETA: 0s - loss: 3.1510 - output_1_loss: 3.0608 - output_2_loss: 3.9628" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 96/363 [======>.......................] - ETA: 0s - loss: 3.1317 - output_1_loss: 3.0685 - output_2_loss: 3.7005" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "139/363 [==========>...................] - ETA: 0s - loss: 3.0868 - output_1_loss: 3.0245 - output_2_loss: 3.6475" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "186/363 [==============>...............] - ETA: 0s - loss: 3.0567 - output_1_loss: 2.9829 - output_2_loss: 3.7207" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "235/363 [==================>...........] - ETA: 0s - loss: 3.0746 - output_1_loss: 2.9889 - output_2_loss: 3.8455" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "288/363 [======================>.......] - ETA: 0s - loss: 3.0133 - output_1_loss: 2.9317 - output_2_loss: 3.7479" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "336/363 [==========================>...] - ETA: 0s - loss: 3.0031 - output_1_loss: 2.8997 - output_2_loss: 3.9336" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 2.9813 - output_1_loss: 2.8787 - output_2_loss: 3.9055 - val_loss: 9.8886 - val_output_1_loss: 9.6674 - val_output_2_loss: 11.8800\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 4/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.9687 - output_1_loss: 1.9417 - output_2_loss: 2.2123" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 53/363 [===>..........................] - ETA: 0s - loss: 3.1077 - output_1_loss: 2.8441 - output_2_loss: 5.4795" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "106/363 [=======>......................] - ETA: 0s - loss: 2.7774 - output_1_loss: 2.5984 - output_2_loss: 4.3885" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "160/363 [============>.................] - ETA: 0s - loss: 2.6253 - output_1_loss: 2.4687 - output_2_loss: 4.0350" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "207/363 [================>.............] - ETA: 0s - loss: 2.5731 - output_1_loss: 2.4303 - output_2_loss: 3.8581" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "261/363 [====================>.........] - ETA: 0s - loss: 2.5021 - output_1_loss: 2.3671 - output_2_loss: 3.7170" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "314/363 [========================>.....] - ETA: 0s - loss: 2.4502 - output_1_loss: 2.3205 - output_2_loss: 3.6177" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 2.4344 - output_1_loss: 2.3071 - output_2_loss: 3.5801 - val_loss: 9.8739 - val_output_1_loss: 9.7212 - val_output_2_loss: 11.2478\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 5/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 2.5113 - output_1_loss: 2.4388 - output_2_loss: 3.1637" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 56/363 [===>..........................] - ETA: 0s - loss: 2.3384 - output_1_loss: 2.1518 - output_2_loss: 4.0173" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "104/363 [=======>......................] - ETA: 0s - loss: 2.2213 - output_1_loss: 2.0743 - output_2_loss: 3.5444" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "150/363 [===========>..................] - ETA: 0s - loss: 2.1361 - output_1_loss: 2.0051 - output_2_loss: 3.3151" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "201/363 [===============>..............] - ETA: 0s - loss: 2.1018 - output_1_loss: 1.9487 - output_2_loss: 3.4799" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "251/363 [===================>..........] - ETA: 0s - loss: 2.0640 - output_1_loss: 1.9160 - output_2_loss: 3.3964" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "302/363 [=======================>......] - ETA: 0s - loss: 2.0455 - output_1_loss: 1.8993 - output_2_loss: 3.3611" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "353/363 [============================>.] - ETA: 0s - loss: 2.0786 - output_1_loss: 1.9393 - output_2_loss: 3.3318" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 2.0728 - output_1_loss: 1.9342 - output_2_loss: 3.3204 - val_loss: 9.1247 - val_output_1_loss: 9.0077 - val_output_2_loss: 10.1777\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 6/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 1.0240 - output_1_loss: 0.9778 - output_2_loss: 1.4401" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 51/363 [===>..........................] - ETA: 0s - loss: 1.8917 - output_1_loss: 1.7541 - output_2_loss: 3.1298" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "102/363 [=======>......................] - ETA: 0s - loss: 1.8304 - output_1_loss: 1.7160 - output_2_loss: 2.8603" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "154/363 [===========>..................] - ETA: 0s - loss: 1.8077 - output_1_loss: 1.6854 - output_2_loss: 2.9082" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "203/363 [===============>..............] - ETA: 0s - loss: 1.8809 - output_1_loss: 1.7571 - output_2_loss: 2.9953" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "252/363 [===================>..........] - ETA: 0s - loss: 1.8632 - output_1_loss: 1.7383 - output_2_loss: 2.9875" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "301/363 [=======================>......] - ETA: 0s - loss: 1.8733 - output_1_loss: 1.7290 - output_2_loss: 3.1720" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "352/363 [============================>.] - ETA: 0s - loss: 1.8348 - output_1_loss: 1.6921 - output_2_loss: 3.1197" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.8235 - output_1_loss: 1.6825 - output_2_loss: 3.0927 - val_loss: 8.4011 - val_output_1_loss: 8.3001 - val_output_2_loss: 9.3098\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 7/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.5903 - output_1_loss: 1.4835 - output_2_loss: 2.5516" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 54/363 [===>..........................] - ETA: 0s - loss: 1.5687 - output_1_loss: 1.4613 - output_2_loss: 2.5352" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "103/363 [=======>......................] - ETA: 0s - loss: 1.6021 - output_1_loss: 1.4885 - output_2_loss: 2.6243" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "153/363 [===========>..................] - ETA: 0s - loss: 1.6556 - output_1_loss: 1.5085 - output_2_loss: 2.9796" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "204/363 [===============>..............] - ETA: 0s - loss: 1.6590 - output_1_loss: 1.5031 - output_2_loss: 3.0621" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "256/363 [====================>.........] - ETA: 0s - loss: 1.7237 - output_1_loss: 1.5714 - output_2_loss: 3.0949" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "308/363 [========================>.....] - ETA: 0s - loss: 1.6764 - output_1_loss: 1.5309 - output_2_loss: 2.9857" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "358/363 [============================>.] - ETA: 0s - loss: 1.6495 - output_1_loss: 1.5082 - output_2_loss: 2.9210" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.6454 - output_1_loss: 1.5047 - output_2_loss: 2.9119 - val_loss: 7.6133 - val_output_1_loss: 7.5168 - val_output_2_loss: 8.4824\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 8/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.3825 - output_1_loss: 1.2845 - output_2_loss: 2.2640" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 54/363 [===>..........................] - ETA: 0s - loss: 1.4973 - output_1_loss: 1.3746 - output_2_loss: 2.6014" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "104/363 [=======>......................] - ETA: 0s - loss: 1.4948 - output_1_loss: 1.3711 - output_2_loss: 2.6079" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "159/363 [============>.................] - ETA: 0s - loss: 1.4934 - output_1_loss: 1.3685 - output_2_loss: 2.6174" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "209/363 [================>.............] - ETA: 0s - loss: 1.4920 - output_1_loss: 1.3648 - output_2_loss: 2.6364" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "259/363 [====================>.........] - ETA: 0s - loss: 1.5492 - output_1_loss: 1.4191 - output_2_loss: 2.7209" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "305/363 [========================>.....] - ETA: 0s - loss: 1.5131 - output_1_loss: 1.3869 - output_2_loss: 2.6493" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "354/363 [============================>.] - ETA: 0s - loss: 1.5159 - output_1_loss: 1.3761 - output_2_loss: 2.7740" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 1.5134 - output_1_loss: 1.3747 - output_2_loss: 2.7617 - val_loss: 6.8256 - val_output_1_loss: 6.7243 - val_output_2_loss: 7.7376\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 9/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 1.9564 - output_1_loss: 1.8695 - output_2_loss: 2.7385" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 50/363 [===>..........................] - ETA: 0s - loss: 1.4105 - output_1_loss: 1.2855 - output_2_loss: 2.5356" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 96/363 [======>.......................] - ETA: 0s - loss: 1.3449 - output_1_loss: 1.2343 - output_2_loss: 2.3405" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "146/363 [===========>..................] - ETA: 0s - loss: 1.3721 - output_1_loss: 1.2571 - output_2_loss: 2.4074" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "196/363 [===============>..............] - ETA: 0s - loss: 1.3777 - output_1_loss: 1.2489 - output_2_loss: 2.5369" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "248/363 [===================>..........] - ETA: 0s - loss: 1.4463 - output_1_loss: 1.3033 - output_2_loss: 2.7331" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "297/363 [=======================>......] - ETA: 0s - loss: 1.4352 - output_1_loss: 1.2943 - output_2_loss: 2.7037" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "346/363 [===========================>..] - ETA: 0s - loss: 1.4188 - output_1_loss: 1.2805 - output_2_loss: 2.6633" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.4119 - output_1_loss: 1.2751 - output_2_loss: 2.6428 - val_loss: 6.0924 - val_output_1_loss: 5.9825 - val_output_2_loss: 7.0812\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 10/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.9065 - output_1_loss: 0.8534 - output_2_loss: 1.3838" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 51/363 [===>..........................] - ETA: 0s - loss: 1.3488 - output_1_loss: 1.1433 - output_2_loss: 3.1982" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "101/363 [=======>......................] - ETA: 0s - loss: 1.3550 - output_1_loss: 1.1842 - output_2_loss: 2.8915" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "152/363 [===========>..................] - ETA: 0s - loss: 1.4026 - output_1_loss: 1.2485 - output_2_loss: 2.7898" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "200/363 [===============>..............] - ETA: 0s - loss: 1.3824 - output_1_loss: 1.2375 - output_2_loss: 2.6867" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "249/363 [===================>..........] - ETA: 0s - loss: 1.3488 - output_1_loss: 1.2108 - output_2_loss: 2.5899" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "298/363 [=======================>......] - ETA: 0s - loss: 1.3500 - output_1_loss: 1.2100 - output_2_loss: 2.6099" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "349/363 [===========================>..] - ETA: 0s - loss: 1.3370 - output_1_loss: 1.2008 - output_2_loss: 2.5630" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.3303 - output_1_loss: 1.1955 - output_2_loss: 2.5440 - val_loss: 5.4380 - val_output_1_loss: 5.3196 - val_output_2_loss: 6.5039\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 11/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.5180 - output_1_loss: 1.3963 - output_2_loss: 2.6139" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/363 [===>..........................] - ETA: 0s - loss: 1.3030 - output_1_loss: 1.1988 - output_2_loss: 2.2416" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "105/363 [=======>......................] - ETA: 0s - loss: 1.2512 - output_1_loss: 1.1434 - output_2_loss: 2.2213" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "154/363 [===========>..................] - ETA: 0s - loss: 1.2433 - output_1_loss: 1.1285 - output_2_loss: 2.2770" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "205/363 [===============>..............] - ETA: 0s - loss: 1.2307 - output_1_loss: 1.1113 - output_2_loss: 2.3052" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "250/363 [===================>..........] - ETA: 0s - loss: 1.2559 - output_1_loss: 1.1394 - output_2_loss: 2.3045" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "303/363 [========================>.....] - ETA: 0s - loss: 1.2760 - output_1_loss: 1.1442 - output_2_loss: 2.4626" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "354/363 [============================>.] - ETA: 0s - loss: 1.2682 - output_1_loss: 1.1351 - output_2_loss: 2.4661" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.2631 - output_1_loss: 1.1304 - output_2_loss: 2.4568 - val_loss: 4.8119 - val_output_1_loss: 4.6836 - val_output_2_loss: 5.9661\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 12/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.9196 - output_1_loss: 1.1303 - output_2_loss: 9.0233" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 54/363 [===>..........................] - ETA: 0s - loss: 1.2117 - output_1_loss: 1.0882 - output_2_loss: 2.3228" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "105/363 [=======>......................] - ETA: 0s - loss: 1.1847 - output_1_loss: 1.0502 - output_2_loss: 2.3946" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "156/363 [===========>..................] - ETA: 0s - loss: 1.1920 - output_1_loss: 1.0636 - output_2_loss: 2.3473" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "208/363 [================>.............] - ETA: 0s - loss: 1.1882 - output_1_loss: 1.0635 - output_2_loss: 2.3106" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "260/363 [====================>.........] - ETA: 0s - loss: 1.2008 - output_1_loss: 1.0623 - output_2_loss: 2.4469" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "311/363 [========================>.....] - ETA: 0s - loss: 1.2303 - output_1_loss: 1.0943 - output_2_loss: 2.4544" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "362/363 [============================>.] - ETA: 0s - loss: 1.2061 - output_1_loss: 1.0754 - output_2_loss: 2.3827" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.2060 - output_1_loss: 1.0753 - output_2_loss: 2.3819 - val_loss: 4.2704 - val_output_1_loss: 4.1343 - val_output_2_loss: 5.4956\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 13/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.8407 - output_1_loss: 0.7319 - output_2_loss: 1.8197" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 51/363 [===>..........................] - ETA: 0s - loss: 1.1896 - output_1_loss: 1.0395 - output_2_loss: 2.5410" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "101/363 [=======>......................] - ETA: 0s - loss: 1.1840 - output_1_loss: 1.0433 - output_2_loss: 2.4503" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "152/363 [===========>..................] - ETA: 0s - loss: 1.1807 - output_1_loss: 1.0480 - output_2_loss: 2.3753" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "199/363 [===============>..............] - ETA: 0s - loss: 1.1746 - output_1_loss: 1.0325 - output_2_loss: 2.4533" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "248/363 [===================>..........] - ETA: 0s - loss: 1.1553 - output_1_loss: 1.0213 - output_2_loss: 2.3614" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "300/363 [=======================>......] - ETA: 0s - loss: 1.1751 - output_1_loss: 1.0439 - output_2_loss: 2.3566" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "347/363 [===========================>..] - ETA: 0s - loss: 1.1645 - output_1_loss: 1.0341 - output_2_loss: 2.3378" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.1569 - output_1_loss: 1.0282 - output_2_loss: 2.3154 - val_loss: 3.8016 - val_output_1_loss: 3.6593 - val_output_2_loss: 5.0825\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 14/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.6749 - output_1_loss: 0.6196 - output_2_loss: 1.1729" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 51/363 [===>..........................] - ETA: 0s - loss: 1.0651 - output_1_loss: 0.9537 - output_2_loss: 2.0670" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "101/363 [=======>......................] - ETA: 0s - loss: 1.1188 - output_1_loss: 1.0119 - output_2_loss: 2.0807" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "153/363 [===========>..................] - ETA: 0s - loss: 1.1152 - output_1_loss: 0.9961 - output_2_loss: 2.1875" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "206/363 [================>.............] - ETA: 0s - loss: 1.1078 - output_1_loss: 0.9791 - output_2_loss: 2.2658" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "258/363 [====================>.........] - ETA: 0s - loss: 1.1258 - output_1_loss: 0.9924 - output_2_loss: 2.3263" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "308/363 [========================>.....] - ETA: 0s - loss: 1.1181 - output_1_loss: 0.9886 - output_2_loss: 2.2832" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "361/363 [============================>.] - ETA: 0s - loss: 1.1158 - output_1_loss: 0.9885 - output_2_loss: 2.2618" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.1142 - output_1_loss: 0.9871 - output_2_loss: 2.2578 - val_loss: 3.4050 - val_output_1_loss: 3.2588 - val_output_2_loss: 4.7216\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 15/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.9080 - output_1_loss: 0.8253 - output_2_loss: 1.6530" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 54/363 [===>..........................] - ETA: 0s - loss: 1.0464 - output_1_loss: 0.9325 - output_2_loss: 2.0720" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "104/363 [=======>......................] - ETA: 0s - loss: 1.0424 - output_1_loss: 0.9301 - output_2_loss: 2.0531" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "156/363 [===========>..................] - ETA: 0s - loss: 1.0765 - output_1_loss: 0.9597 - output_2_loss: 2.1278" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "209/363 [================>.............] - ETA: 0s - loss: 1.0646 - output_1_loss: 0.9435 - output_2_loss: 2.1545" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "258/363 [====================>.........] - ETA: 0s - loss: 1.0737 - output_1_loss: 0.9514 - output_2_loss: 2.1739" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "306/363 [========================>.....] - ETA: 0s - loss: 1.0697 - output_1_loss: 0.9493 - output_2_loss: 2.1530" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "359/363 [============================>.] - ETA: 0s - loss: 1.0771 - output_1_loss: 0.9517 - output_2_loss: 2.2064" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.0767 - output_1_loss: 0.9515 - output_2_loss: 2.2030 - val_loss: 3.0595 - val_output_1_loss: 2.9105 - val_output_2_loss: 4.4004\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 16/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.3305 - output_1_loss: 1.1126 - output_2_loss: 3.2913" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 55/363 [===>..........................] - ETA: 0s - loss: 1.1316 - output_1_loss: 1.0014 - output_2_loss: 2.3039" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "105/363 [=======>......................] - ETA: 0s - loss: 1.0981 - output_1_loss: 0.9763 - output_2_loss: 2.1950" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "158/363 [============>.................] - ETA: 0s - loss: 1.0721 - output_1_loss: 0.9552 - output_2_loss: 2.1243" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "211/363 [================>.............] - ETA: 0s - loss: 1.0573 - output_1_loss: 0.9424 - output_2_loss: 2.0917" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "262/363 [====================>.........] - ETA: 0s - loss: 1.0523 - output_1_loss: 0.9283 - output_2_loss: 2.1680" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "314/363 [========================>.....] - ETA: 0s - loss: 1.0354 - output_1_loss: 0.9132 - output_2_loss: 2.1352" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "362/363 [============================>.] - ETA: 0s - loss: 1.0443 - output_1_loss: 0.9209 - output_2_loss: 2.1551" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 1.0435 - output_1_loss: 0.9200 - output_2_loss: 2.1545 - val_loss: 2.7641 - val_output_1_loss: 2.6134 - val_output_2_loss: 4.1204\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 17/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 1.1472 - output_1_loss: 0.9948 - output_2_loss: 2.5193" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 53/363 [===>..........................] - ETA: 0s - loss: 1.0097 - output_1_loss: 0.8798 - output_2_loss: 2.1786" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "106/363 [=======>......................] - ETA: 0s - loss: 0.9986 - output_1_loss: 0.8812 - output_2_loss: 2.0546" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "156/363 [===========>..................] - ETA: 0s - loss: 1.0094 - output_1_loss: 0.8929 - output_2_loss: 2.0576" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "206/363 [================>.............] - ETA: 0s - loss: 0.9963 - output_1_loss: 0.8797 - output_2_loss: 2.0450" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "257/363 [====================>.........] - ETA: 0s - loss: 0.9980 - output_1_loss: 0.8740 - output_2_loss: 2.1140" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "303/363 [========================>.....] - ETA: 0s - loss: 1.0135 - output_1_loss: 0.8902 - output_2_loss: 2.1236" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "354/363 [============================>.] - ETA: 0s - loss: 1.0144 - output_1_loss: 0.8917 - output_2_loss: 2.1182" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.0140 - output_1_loss: 0.8923 - output_2_loss: 2.1099 - val_loss: 2.5018 - val_output_1_loss: 2.3494 - val_output_2_loss: 3.8739\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 18/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.8493 - output_1_loss: 0.7842 - output_2_loss: 1.4353" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 55/363 [===>..........................] - ETA: 0s - loss: 0.9539 - output_1_loss: 0.8359 - output_2_loss: 2.0159" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "107/363 [=======>......................] - ETA: 0s - loss: 0.9541 - output_1_loss: 0.8415 - output_2_loss: 1.9673" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "158/363 [============>.................] - ETA: 0s - loss: 0.9774 - output_1_loss: 0.8599 - output_2_loss: 2.0354" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "207/363 [================>.............] - ETA: 0s - loss: 0.9876 - output_1_loss: 0.8668 - output_2_loss: 2.0747" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "256/363 [====================>.........] - ETA: 0s - loss: 0.9770 - output_1_loss: 0.8559 - output_2_loss: 2.0663" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "307/363 [========================>.....] - ETA: 0s - loss: 1.0019 - output_1_loss: 0.8779 - output_2_loss: 2.1173" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "353/363 [============================>.] - ETA: 0s - loss: 0.9938 - output_1_loss: 0.8729 - output_2_loss: 2.0818" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 0.9876 - output_1_loss: 0.8676 - output_2_loss: 2.0678 - val_loss: 2.2811 - val_output_1_loss: 2.1274 - val_output_2_loss: 3.6643\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 19/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.6459 - output_1_loss: 0.5558 - output_2_loss: 1.4569" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 51/363 [===>..........................] - ETA: 0s - loss: 0.9932 - output_1_loss: 0.8923 - output_2_loss: 1.9013" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "100/363 [=======>......................] - ETA: 0s - loss: 0.9784 - output_1_loss: 0.8719 - output_2_loss: 1.9373" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "152/363 [===========>..................] - ETA: 0s - loss: 0.9856 - output_1_loss: 0.8748 - output_2_loss: 1.9831" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "201/363 [===============>..............] - ETA: 0s - loss: 0.9924 - output_1_loss: 0.8730 - output_2_loss: 2.0668" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "253/363 [===================>..........] - ETA: 0s - loss: 0.9778 - output_1_loss: 0.8599 - output_2_loss: 2.0383" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "299/363 [=======================>......] - ETA: 0s - loss: 0.9800 - output_1_loss: 0.8558 - output_2_loss: 2.0986" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "345/363 [===========================>..] - ETA: 0s - loss: 0.9679 - output_1_loss: 0.8480 - output_2_loss: 2.0469" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.9639 - output_1_loss: 0.8455 - output_2_loss: 2.0291 - val_loss: 2.0931 - val_output_1_loss: 1.9392 - val_output_2_loss: 3.4779\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 20/20\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.9185 - output_1_loss: 0.7133 - output_2_loss: 2.7648" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 49/363 [===>..........................] - ETA: 0s - loss: 0.9584 - output_1_loss: 0.8310 - output_2_loss: 2.1053" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "100/363 [=======>......................] - ETA: 0s - loss: 0.9459 - output_1_loss: 0.8274 - output_2_loss: 2.0125" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "151/363 [===========>..................] - ETA: 0s - loss: 0.9363 - output_1_loss: 0.8224 - output_2_loss: 1.9617" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "200/363 [===============>..............] - ETA: 0s - loss: 0.9138 - output_1_loss: 0.8049 - output_2_loss: 1.8944" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "252/363 [===================>..........] - ETA: 0s - loss: 0.9145 - output_1_loss: 0.8067 - output_2_loss: 1.8843" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "302/363 [=======================>......] - ETA: 0s - loss: 0.9328 - output_1_loss: 0.8239 - output_2_loss: 1.9132" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "353/363 [============================>.] - ETA: 0s - loss: 0.9433 - output_1_loss: 0.8266 - output_2_loss: 1.9939" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.9424 - output_1_loss: 0.8257 - output_2_loss: 1.9931 - val_loss: 1.9300 - val_output_1_loss: 1.7766 - val_output_2_loss: 3.3108\n" + ] + } + ], + "source": [ + "history = model.fit((X_train_A, X_train_B), (y_train, y_train), epochs=20,\n", + " validation_data=((X_valid_A, X_valid_B), (y_valid, y_valid)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Evaluating and making predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:12.855457Z", + "iopub.status.busy": "2024-01-10T00:22:12.854906Z", + "iopub.status.idle": "2024-01-10T00:22:13.324589Z", + "shell.execute_reply": "2024-01-10T00:22:13.323865Z" + }, + "tags": [ + "hide-output" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/162 [..............................] - ETA: 3s - loss: 1.2951 - output_1_loss: 1.1938 - output_2_loss: 2.2066" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/162 [========>.....................] - ETA: 0s - loss: 0.9102 - output_1_loss: 0.8088 - output_2_loss: 1.8225" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "107/162 [==================>...........] - ETA: 0s - loss: 0.8964 - output_1_loss: 0.7964 - output_2_loss: 1.7962" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "162/162 [==============================] - 0s 934us/step - loss: 0.9276 - output_1_loss: 0.7995 - output_2_loss: 2.0800\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "1/1 [==============================] - ETA: 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1/1 [==============================] - 0s 53ms/step\n" + ] + } + ], + "source": [ + "total_loss, main_loss, aux_loss = model.evaluate((X_test_A, X_test_B), (y_test, y_test))\n", + "y_pred_main, y_pred_aux = model.predict((X_new_A, X_new_B))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Saving and restoring models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Keras can be used to easily save and restore models when using the *Sequential API* of the *Functional API*.\n", + "\n", + "Models can of course be saved and restored when using the *Subclassing API* but it is necessary to use underlying TensorFlow methods and is not quite so straightforward (not covered further here)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "Let's build and train a simple model and then save and restore it." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:13.328041Z", + "iopub.status.busy": "2024-01-10T00:22:13.327419Z", + "iopub.status.idle": "2024-01-10T00:22:13.357840Z", + "shell.execute_reply": "2024-01-10T00:22:13.357151Z" + } + }, + "outputs": [], + "source": [ + "model = keras.models.Sequential([\n", + " keras.layers.Dense(30, activation=\"relu\", input_shape=[8]),\n", + " keras.layers.Dense(30, activation=\"relu\"),\n", + " keras.layers.Dense(1)\n", + "]) " + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:13.361232Z", + "iopub.status.busy": "2024-01-10T00:22:13.360762Z", + "iopub.status.idle": "2024-01-10T00:22:18.121001Z", + "shell.execute_reply": "2024-01-10T00:22:18.120333Z" + }, + "tags": [ + "hide-output" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1:23 - loss: 4.5745" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 62/363 [====>.........................] - ETA: 0s - loss: 4.7668 " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "119/363 [========>.....................] - ETA: 0s - loss: 4.6584" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "175/363 [=============>................] - ETA: 0s - loss: 4.4761" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "235/363 [==================>...........] - ETA: 0s - loss: 4.3275" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "294/363 [=======================>......] - ETA: 0s - loss: 4.1768" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "350/363 [===========================>..] - ETA: 0s - loss: 4.0678" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 4.0410 - val_loss: 5.5778\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 2/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 3.0976" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 60/363 [===>..........................] - ETA: 0s - loss: 2.9435" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "118/363 [========>.....................] - ETA: 0s - loss: 2.9655" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "177/363 [=============>................] - ETA: 0s - loss: 2.9346" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "234/363 [==================>...........] - ETA: 0s - loss: 2.8576" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "291/363 [=======================>......] - ETA: 0s - loss: 2.8196" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "347/363 [===========================>..] - ETA: 0s - loss: 2.7350" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 2.7145 - val_loss: 5.8976\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 3/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 2.5945" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 60/363 [===>..........................] - ETA: 0s - loss: 2.1624" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "117/363 [========>.....................] - ETA: 0s - loss: 2.1596" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "176/363 [=============>................] - ETA: 0s - loss: 2.1285" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "235/363 [==================>...........] - ETA: 0s - loss: 2.0518" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "293/363 [=======================>......] - ETA: 0s - loss: 2.0009" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "351/363 [============================>.] - ETA: 0s - loss: 1.9754" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.9766 - val_loss: 5.5406\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 4/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.7472" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 55/363 [===>..........................] - ETA: 0s - loss: 1.5824" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "114/363 [========>.....................] - ETA: 0s - loss: 1.6371" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "173/363 [=============>................] - ETA: 0s - loss: 1.6401" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "234/363 [==================>...........] - ETA: 0s - loss: 1.5786" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "296/363 [=======================>......] - ETA: 0s - loss: 1.5782" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "353/363 [============================>.] - ETA: 0s - loss: 1.5413" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.5339 - val_loss: 4.7627\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 5/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 1.2416" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 57/363 [===>..........................] - ETA: 0s - loss: 1.2652" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "113/363 [========>.....................] - ETA: 0s - loss: 1.3606" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "171/363 [=============>................] - ETA: 0s - loss: 1.2956" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "228/363 [=================>............] - ETA: 0s - loss: 1.2822" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "289/363 [======================>.......] - ETA: 0s - loss: 1.2741" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "347/363 [===========================>..] - ETA: 0s - loss: 1.2408" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.2504 - val_loss: 3.8661\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 6/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.5635" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 59/363 [===>..........................] - ETA: 0s - loss: 1.0937" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "119/363 [========>.....................] - ETA: 0s - loss: 1.0923" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "176/363 [=============>................] - ETA: 0s - loss: 1.0825" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "227/363 [=================>............] - ETA: 0s - loss: 1.0764" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "286/363 [======================>.......] - ETA: 0s - loss: 1.0528" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "343/363 [===========================>..] - ETA: 0s - loss: 1.0436" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.0633 - val_loss: 3.0605\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 7/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.7616" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 60/363 [===>..........................] - ETA: 0s - loss: 0.9854" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "117/363 [========>.....................] - ETA: 0s - loss: 0.9695" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "174/363 [=============>................] - ETA: 0s - loss: 0.9725" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "231/363 [==================>...........] - ETA: 0s - loss: 0.9754" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "287/363 [======================>.......] - ETA: 0s - loss: 0.9527" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "346/363 [===========================>..] - ETA: 0s - loss: 0.9369" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.9394 - val_loss: 2.3733\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 8/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.1187" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 59/363 [===>..........................] - ETA: 0s - loss: 0.9431" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "117/363 [========>.....................] - ETA: 0s - loss: 0.9068" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "176/363 [=============>................] - ETA: 0s - loss: 0.8842" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "236/363 [==================>...........] - ETA: 0s - loss: 0.8673" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "294/363 [=======================>......] - ETA: 0s - loss: 0.8795" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "346/363 [===========================>..] - ETA: 0s - loss: 0.8639" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.8583 - val_loss: 1.9333\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 9/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.8088" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 60/363 [===>..........................] - ETA: 0s - loss: 0.8009" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "122/363 [=========>....................] - ETA: 0s - loss: 0.8181" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "183/363 [==============>...............] - ETA: 0s - loss: 0.8112" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "242/363 [===================>..........] - ETA: 0s - loss: 0.8092" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "298/363 [=======================>......] - ETA: 0s - loss: 0.8075" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "357/363 [============================>.] - ETA: 0s - loss: 0.8048" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.8048 - val_loss: 1.5947\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 10/10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.8307" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 60/363 [===>..........................] - ETA: 0s - loss: 0.7763" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "117/363 [========>.....................] - ETA: 0s - loss: 0.7832" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "173/363 [=============>................] - ETA: 0s - loss: 0.7817" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "227/363 [=================>............] - ETA: 0s - loss: 0.7576" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "287/363 [======================>.......] - ETA: 0s - loss: 0.7532" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "342/363 [===========================>..] - ETA: 0s - loss: 0.7681" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.7680 - val_loss: 1.3381\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/162 [..............................] - ETA: 2s - loss: 0.8639" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 61/162 [==========>...................] - ETA: 0s - loss: 0.7393" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "125/162 [======================>.......] - ETA: 0s - loss: 0.7472" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "162/162 [==============================] - 0s 828us/step - loss: 0.7463\n" + ] + } + ], + "source": [ + "model.compile(loss=\"mse\", optimizer=keras.optimizers.legacy.SGD(learning_rate=1e-4))\n", + "history = model.fit(X_train, y_train, epochs=10, validation_data=(X_valid, y_valid))\n", + "mse_test = model.evaluate(X_test, y_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Saving" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Saving the model is simply one line." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:18.124297Z", + "iopub.status.busy": "2024-01-10T00:22:18.123847Z", + "iopub.status.idle": "2024-01-10T00:22:18.141254Z", + "shell.execute_reply": "2024-01-10T00:22:18.140258Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/hostedtoolcache/Python/3.8.18/x64/lib/python3.8/site-packages/keras/src/engine/training.py:3000: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n", + " saving_api.save_model(\n" + ] + } + ], + "source": [ + "model.save(\"my_keras_model.h5\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model is then saved using the Keras format.\n", + "\n", + "The model's achitecture, values of the model parameters, the optimiser, hyperparameters, and state are all saved." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Restoring" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Restoring the model is also just one line." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:18.144582Z", + "iopub.status.busy": "2024-01-10T00:22:18.144138Z", + "iopub.status.idle": "2024-01-10T00:22:18.192583Z", + "shell.execute_reply": "2024-01-10T00:22:18.191888Z" + } + }, + "outputs": [], + "source": [ + "model = keras.models.load_model(\"my_keras_model.h5\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model can then be used as usual, e.g. to make predictions." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:18.195962Z", + "iopub.status.busy": "2024-01-10T00:22:18.195387Z", + "iopub.status.idle": "2024-01-10T00:22:18.275735Z", + "shell.execute_reply": "2024-01-10T00:22:18.275029Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "1/1 [==============================] - ETA: 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "1/1 [==============================] - 0s 43ms/step\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[1.0386337],\n", + " [1.1102493],\n", + " [2.4406295]], dtype=float32)" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.predict(X_new)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Checkpointing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since training may take a long time, you might like to save the model weights as training progresses so that you do not lose the results if the machine crashes or disconnects.\n", + "\n", + "Model weights can also be saved and loaded in a single line." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:18.279177Z", + "iopub.status.busy": "2024-01-10T00:22:18.278601Z", + "iopub.status.idle": "2024-01-10T00:22:18.311330Z", + "shell.execute_reply": "2024-01-10T00:22:18.310629Z" + } + }, + "outputs": [], + "source": [ + "model.save_weights(\"my_keras_weights.ckpt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:18.314929Z", + "iopub.status.busy": "2024-01-10T00:22:18.314461Z", + "iopub.status.idle": "2024-01-10T00:22:18.327907Z", + "shell.execute_reply": "2024-01-10T00:22:18.327234Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.load_weights(\"my_keras_weights.ckpt\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## TensorBoard" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TensorBoard is an interactive visualisation tool that you can use to review learning curves, analyse training statistics and inspect the architecture of your model." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Logging" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's log a training run and model and then view in TensorBoard." + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:18.331174Z", + "iopub.status.busy": "2024-01-10T00:22:18.330725Z", + "iopub.status.idle": "2024-01-10T00:22:18.335250Z", + "shell.execute_reply": "2024-01-10T00:22:18.334632Z" + } + }, + "outputs": [], + "source": [ + "root_logdir = os.path.join(os.curdir, \"my_logs\")" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:18.338327Z", + "iopub.status.busy": "2024-01-10T00:22:18.337925Z", + "iopub.status.idle": "2024-01-10T00:22:18.345195Z", + "shell.execute_reply": "2024-01-10T00:22:18.344564Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'./my_logs/run_2024_01_10-00_22_18'" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def get_run_logdir():\n", + " import time\n", + " run_id = time.strftime(\"run_%Y_%m_%d-%H_%M_%S\")\n", + " return os.path.join(root_logdir, run_id)\n", + "\n", + "run_logdir = get_run_logdir()\n", + "run_logdir" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:18.348133Z", + "iopub.status.busy": "2024-01-10T00:22:18.347677Z", + "iopub.status.idle": "2024-01-10T00:22:18.367784Z", + "shell.execute_reply": "2024-01-10T00:22:18.367141Z" + } + }, + "outputs": [], + "source": [ + "keras.backend.clear_session()\n", + "np.random.seed(42)\n", + "tf.random.set_seed(42)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:18.371176Z", + "iopub.status.busy": "2024-01-10T00:22:18.370711Z", + "iopub.status.idle": "2024-01-10T00:22:18.421276Z", + "shell.execute_reply": "2024-01-10T00:22:18.420572Z" + } + }, + "outputs": [], + "source": [ + "model = keras.models.Sequential([\n", + " keras.layers.Dense(30, activation=\"relu\", input_shape=[8]),\n", + " keras.layers.Dense(30, activation=\"relu\"),\n", + " keras.layers.Dense(1)\n", + "]) \n", + "model.compile(loss=\"mse\", optimizer=keras.optimizers.legacy.SGD(learning_rate=1e-4))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "To log training as it progresses we need to set up `callback`. \n", + "\n", + "The `fit` methods allows a list of `callbacks` to be specified, which can then be called at the start and end of each epoch." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's set up two callbacks:\n", + "- One to checkpoint the model as we go, saving the best model considered so far, as evaluated on the validation set.\n", + "- One to log TensorBoard data." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:18.424935Z", + "iopub.status.busy": "2024-01-10T00:22:18.424442Z", + "iopub.status.idle": "2024-01-10T00:22:18.428934Z", + "shell.execute_reply": "2024-01-10T00:22:18.428249Z" + } + }, + "outputs": [], + "source": [ + "checkpoint_cb = keras.callbacks.ModelCheckpoint(\"my_keras_model.h5\", save_best_only=True)\n", + "tensorboard_cb = keras.callbacks.TensorBoard(run_logdir)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "The callbacks are then simply passed to the `fit` method." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "execution": { + "iopub.execute_input": "2024-01-10T00:22:18.432160Z", + "iopub.status.busy": "2024-01-10T00:22:18.431626Z", + "iopub.status.idle": "2024-01-10T00:22:33.678714Z", + "shell.execute_reply": "2024-01-10T00:22:33.678012Z" + }, + "tags": [ + "hide-output" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1:27 - loss: 7.0073" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 53/363 [===>..........................] - ETA: 0s - loss: 6.0794 " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "104/363 [=======>......................] - ETA: 0s - loss: 5.9392" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "154/363 [===========>..................] - ETA: 0s - loss: 5.7578" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "203/363 [===============>..............] - ETA: 0s - loss: 5.5502" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "254/363 [===================>..........] - ETA: 0s - loss: 5.3746" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "298/363 [=======================>......] - ETA: 0s - loss: 5.2319" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "348/363 [===========================>..] - ETA: 0s - loss: 5.0715" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 2ms/step - loss: 5.0266 - val_loss: 3.9981\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 2/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 3.6957" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 51/363 [===>..........................] - ETA: 0s - loss: 4.0669" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "102/363 [=======>......................] - ETA: 0s - loss: 3.7958" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "152/363 [===========>..................] - ETA: 0s - loss: 3.7398" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "203/363 [===============>..............] - ETA: 0s - loss: 3.6332" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "252/363 [===================>..........] - ETA: 0s - loss: 3.5448" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "303/363 [========================>.....] - ETA: 0s - loss: 3.4541" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "355/363 [============================>.] - ETA: 0s - loss: 3.3867" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 3.3746 - val_loss: 3.7107\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 3/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 2.5212" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 49/363 [===>..........................] - ETA: 0s - loss: 2.7089" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 98/363 [=======>......................] - ETA: 0s - loss: 2.7810" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "147/363 [===========>..................] - ETA: 0s - loss: 2.6700" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "195/363 [===============>..............] - ETA: 0s - loss: 2.6137" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "246/363 [===================>..........] - ETA: 0s - loss: 2.4895" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "296/363 [=======================>......] - ETA: 0s - loss: 2.4503" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "349/363 [===========================>..] - ETA: 0s - loss: 2.3827" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 2.3637 - val_loss: 4.3080\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 4/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 1.1972" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 50/363 [===>..........................] - ETA: 0s - loss: 1.9984" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "100/363 [=======>......................] - ETA: 0s - loss: 1.9325" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "151/363 [===========>..................] - ETA: 0s - loss: 1.8806" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "200/363 [===============>..............] - ETA: 0s - loss: 1.8880" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "249/363 [===================>..........] - ETA: 0s - loss: 1.8404" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "300/363 [=======================>......] - ETA: 0s - loss: 1.7886" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "349/363 [===========================>..] - ETA: 0s - loss: 1.7602" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.7621 - val_loss: 5.0534\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 5/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 2.0113" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 51/363 [===>..........................] - ETA: 0s - loss: 1.5316" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "100/363 [=======>......................] - ETA: 0s - loss: 1.5325" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "150/363 [===========>..................] - ETA: 0s - loss: 1.4557" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "198/363 [===============>..............] - ETA: 0s - loss: 1.4472" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "252/363 [===================>..........] - ETA: 0s - loss: 1.4268" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "306/363 [========================>.....] - ETA: 0s - loss: 1.4428" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "357/363 [============================>.] - ETA: 0s - loss: 1.4288" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.4256 - val_loss: 5.5034\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 6/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.7229" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/363 [===>..........................] - ETA: 0s - loss: 1.2705" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "102/363 [=======>......................] - ETA: 0s - loss: 1.2260" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "153/363 [===========>..................] - ETA: 0s - loss: 1.3087" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "205/363 [===============>..............] - ETA: 0s - loss: 1.3097" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "255/363 [====================>.........] - ETA: 0s - loss: 1.2632" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "304/363 [========================>.....] - ETA: 0s - loss: 1.2515" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "355/363 [============================>.] - ETA: 0s - loss: 1.2356" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.2389 - val_loss: 5.6828\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 7/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.3252" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 50/363 [===>..........................] - ETA: 0s - loss: 1.2337" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 99/363 [=======>......................] - ETA: 0s - loss: 1.2696" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "138/363 [==========>...................] - ETA: 0s - loss: 1.2422" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "189/363 [==============>...............] - ETA: 0s - loss: 1.2061" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "241/363 [==================>...........] - ETA: 0s - loss: 1.1693" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "287/363 [======================>.......] - ETA: 0s - loss: 1.1566" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "336/363 [==========================>...] - ETA: 0s - loss: 1.1391" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 1.1283 - val_loss: 5.6298\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 8/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.7234" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/363 [===>..........................] - ETA: 0s - loss: 1.0851" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "103/363 [=======>......................] - ETA: 0s - loss: 1.0348" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "153/363 [===========>..................] - ETA: 0s - loss: 1.0178" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "206/363 [================>.............] - ETA: 0s - loss: 1.0153" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "258/363 [====================>.........] - ETA: 0s - loss: 1.0339" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "311/363 [========================>.....] - ETA: 0s - loss: 1.0672" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - ETA: 0s - loss: 1.0558" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 1.0558 - val_loss: 5.2461\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 9/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.7812" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 54/363 [===>..........................] - ETA: 0s - loss: 1.0242" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "105/363 [=======>......................] - ETA: 0s - loss: 1.0222" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "154/363 [===========>..................] - ETA: 0s - loss: 1.0254" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "201/363 [===============>..............] - ETA: 0s - loss: 1.0615" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "247/363 [===================>..........] - ETA: 0s - loss: 1.0333" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "298/363 [=======================>......] - ETA: 0s - loss: 1.0176" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "352/363 [============================>.] - ETA: 0s - loss: 1.0050" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 1.0015 - val_loss: 4.8838\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 10/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.1106" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 54/363 [===>..........................] - ETA: 0s - loss: 1.1464" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "105/363 [=======>......................] - ETA: 0s - loss: 1.0388" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "154/363 [===========>..................] - ETA: 0s - loss: 1.0072" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "204/363 [===============>..............] - ETA: 0s - loss: 0.9762" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "257/363 [====================>.........] - ETA: 0s - loss: 0.9810" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "306/363 [========================>.....] - ETA: 0s - loss: 0.9728" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "357/363 [============================>.] - ETA: 0s - loss: 0.9574" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.9580 - val_loss: 4.4096\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 11/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.7875" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 50/363 [===>..........................] - ETA: 0s - loss: 0.9147" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "100/363 [=======>......................] - ETA: 0s - loss: 0.9028" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "150/363 [===========>..................] - ETA: 0s - loss: 0.9084" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "200/363 [===============>..............] - ETA: 0s - loss: 0.9177" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "251/363 [===================>..........] - ETA: 0s - loss: 0.9098" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "300/363 [=======================>......] - ETA: 0s - loss: 0.9096" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "350/363 [===========================>..] - ETA: 0s - loss: 0.9028" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 0.9216 - val_loss: 3.9236\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 12/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.9666" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 55/363 [===>..........................] - ETA: 0s - loss: 1.0438" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "106/363 [=======>......................] - ETA: 0s - loss: 0.9525" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "157/363 [===========>..................] - ETA: 0s - loss: 0.9057" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "208/363 [================>.............] - ETA: 0s - loss: 0.8975" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "258/363 [====================>.........] - ETA: 0s - loss: 0.8954" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "308/363 [========================>.....] - ETA: 0s - loss: 0.8895" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "360/363 [============================>.] - ETA: 0s - loss: 0.8927" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.8912 - val_loss: 3.5522\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 13/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.7108" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/363 [===>..........................] - ETA: 0s - loss: 0.8702" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "103/363 [=======>......................] - ETA: 0s - loss: 0.8932" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "154/363 [===========>..................] - ETA: 0s - loss: 0.8699" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "205/363 [===============>..............] - ETA: 0s - loss: 0.8964" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "255/363 [====================>.........] - ETA: 0s - loss: 0.8664" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "304/363 [========================>.....] - ETA: 0s - loss: 0.8636" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "352/363 [============================>.] - ETA: 0s - loss: 0.8676" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.8648 - val_loss: 3.1969\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 14/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.7758" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/363 [===>..........................] - ETA: 0s - loss: 0.8501" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "101/363 [=======>......................] - ETA: 0s - loss: 0.8557" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "151/363 [===========>..................] - ETA: 0s - loss: 0.8313" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "204/363 [===============>..............] - ETA: 0s - loss: 0.8428" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "258/363 [====================>.........] - ETA: 0s - loss: 0.8623" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "309/363 [========================>.....] - ETA: 0s - loss: 0.8456" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "360/363 [============================>.] - ETA: 0s - loss: 0.8436" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.8420 - val_loss: 2.8708\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 15/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 1.7084" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/363 [===>..........................] - ETA: 0s - loss: 0.8023" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "103/363 [=======>......................] - ETA: 0s - loss: 0.7911" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "156/363 [===========>..................] - ETA: 0s - loss: 0.7855" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "205/363 [===============>..............] - ETA: 0s - loss: 0.8363" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "257/363 [====================>.........] - ETA: 0s - loss: 0.8353" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "308/363 [========================>.....] - ETA: 0s - loss: 0.8396" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "355/363 [============================>.] - ETA: 0s - loss: 0.8260" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.8221 - val_loss: 2.5780\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 16/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.4433" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/363 [===>..........................] - ETA: 0s - loss: 0.8604" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "103/363 [=======>......................] - ETA: 0s - loss: 0.8317" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "154/363 [===========>..................] - ETA: 0s - loss: 0.8237" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "205/363 [===============>..............] - ETA: 0s - loss: 0.8423" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "255/363 [====================>.........] - ETA: 0s - loss: 0.8223" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "308/363 [========================>.....] - ETA: 0s - loss: 0.8173" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "358/363 [============================>.] - ETA: 0s - loss: 0.8063" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.8046 - val_loss: 2.2803\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 17/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.7251" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 51/363 [===>..........................] - ETA: 0s - loss: 0.8027" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "102/363 [=======>......................] - ETA: 0s - loss: 0.7825" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "155/363 [===========>..................] - ETA: 0s - loss: 0.7723" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "205/363 [===============>..............] - ETA: 0s - loss: 0.7848" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "258/363 [====================>.........] - ETA: 0s - loss: 0.7903" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "310/363 [========================>.....] - ETA: 0s - loss: 0.7856" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "361/363 [============================>.] - ETA: 0s - loss: 0.7886" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 0.7890 - val_loss: 2.0466\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 18/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 1.4165" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 50/363 [===>..........................] - ETA: 0s - loss: 0.8062" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "102/363 [=======>......................] - ETA: 0s - loss: 0.7607" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "152/363 [===========>..................] - ETA: 0s - loss: 0.7922" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "202/363 [===============>..............] - ETA: 0s - loss: 0.7761" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "254/363 [===================>..........] - ETA: 0s - loss: 0.7845" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "306/363 [========================>.....] - ETA: 0s - loss: 0.7803" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "356/363 [============================>.] - ETA: 0s - loss: 0.7758" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 0.7750 - val_loss: 1.8276\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 19/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.3563" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 54/363 [===>..........................] - ETA: 0s - loss: 0.6883" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "104/363 [=======>......................] - ETA: 0s - loss: 0.7331" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "153/363 [===========>..................] - ETA: 0s - loss: 0.7352" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "204/363 [===============>..............] - ETA: 0s - loss: 0.7475" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "255/363 [====================>.........] - ETA: 0s - loss: 0.7461" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "306/363 [========================>.....] - ETA: 0s - loss: 0.7626" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "356/363 [============================>.] - ETA: 0s - loss: 0.7634" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 0.7623 - val_loss: 1.6389\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 20/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.4932" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 51/363 [===>..........................] - ETA: 0s - loss: 0.7233" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "101/363 [=======>......................] - ETA: 0s - loss: 0.7505" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "152/363 [===========>..................] - ETA: 0s - loss: 0.7490" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "205/363 [===============>..............] - ETA: 0s - loss: 0.7545" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "254/363 [===================>..........] - ETA: 0s - loss: 0.7606" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "304/363 [========================>.....] - ETA: 0s - loss: 0.7541" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "354/363 [============================>.] - ETA: 0s - loss: 0.7518" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.7508 - val_loss: 1.4776\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 21/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.6476" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 51/363 [===>..........................] - ETA: 0s - loss: 0.7358" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "103/363 [=======>......................] - ETA: 0s - loss: 0.7571" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "154/363 [===========>..................] - ETA: 0s - loss: 0.7647" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "208/363 [================>.............] - ETA: 0s - loss: 0.7548" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "262/363 [====================>.........] - ETA: 0s - loss: 0.7448" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "313/363 [========================>.....] - ETA: 0s - loss: 0.7492" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.7403 - val_loss: 1.3352\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 22/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.8187" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 50/363 [===>..........................] - ETA: 0s - loss: 0.6639" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "101/363 [=======>......................] - ETA: 0s - loss: 0.7484" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "152/363 [===========>..................] - ETA: 0s - loss: 0.7488" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "200/363 [===============>..............] - ETA: 0s - loss: 0.7435" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "252/363 [===================>..........] - ETA: 0s - loss: 0.7305" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "303/363 [========================>.....] - ETA: 0s - loss: 0.7196" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "353/363 [============================>.] - ETA: 0s - loss: 0.7261" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 0.7307 - val_loss: 1.2123\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 23/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.7580" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/363 [===>..........................] - ETA: 0s - loss: 0.7593" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "104/363 [=======>......................] - ETA: 0s - loss: 0.7334" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "155/363 [===========>..................] - ETA: 0s - loss: 0.7327" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "206/363 [================>.............] - ETA: 0s - loss: 0.7351" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "258/363 [====================>.........] - ETA: 0s - loss: 0.7257" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "312/363 [========================>.....] - ETA: 0s - loss: 0.7210" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 0.7218 - val_loss: 1.1042\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 24/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 1.0690" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/363 [===>..........................] - ETA: 0s - loss: 0.7460" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "102/363 [=======>......................] - ETA: 0s - loss: 0.6960" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "154/363 [===========>..................] - ETA: 0s - loss: 0.6995" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "207/363 [================>.............] - ETA: 0s - loss: 0.6976" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "260/363 [====================>.........] - ETA: 0s - loss: 0.7083" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "314/363 [========================>.....] - ETA: 0s - loss: 0.7118" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.7136 - val_loss: 1.0124\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 25/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.7017" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 56/363 [===>..........................] - ETA: 0s - loss: 0.7445" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "112/363 [========>.....................] - ETA: 0s - loss: 0.7176" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "163/363 [============>.................] - ETA: 0s - loss: 0.7022" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "215/363 [================>.............] - ETA: 0s - loss: 0.7034" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "269/363 [=====================>........] - ETA: 0s - loss: 0.7042" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "320/363 [=========================>....] - ETA: 0s - loss: 0.7112" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.7059 - val_loss: 0.9374\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 26/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.8865" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 51/363 [===>..........................] - ETA: 0s - loss: 0.6926" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "100/363 [=======>......................] - ETA: 0s - loss: 0.6956" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "150/363 [===========>..................] - ETA: 0s - loss: 0.7133" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "201/363 [===============>..............] - ETA: 0s - loss: 0.7081" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "251/363 [===================>..........] - ETA: 0s - loss: 0.7111" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "301/363 [=======================>......] - ETA: 0s - loss: 0.7122" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "351/363 [============================>.] - ETA: 0s - loss: 0.7003" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 0.6986 - val_loss: 0.8735\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 27/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.7908" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/363 [===>..........................] - ETA: 0s - loss: 0.6949" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "102/363 [=======>......................] - ETA: 0s - loss: 0.6999" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "153/363 [===========>..................] - ETA: 0s - loss: 0.7168" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "203/363 [===============>..............] - ETA: 0s - loss: 0.7061" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "253/363 [===================>..........] - ETA: 0s - loss: 0.6935" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "307/363 [========================>.....] - ETA: 0s - loss: 0.6976" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "356/363 [============================>.] - ETA: 0s - loss: 0.6909" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.6918 - val_loss: 0.8221\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 28/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.5465" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 53/363 [===>..........................] - ETA: 0s - loss: 0.6792" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "103/363 [=======>......................] - ETA: 0s - loss: 0.6867" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "153/363 [===========>..................] - ETA: 0s - loss: 0.6921" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "204/363 [===============>..............] - ETA: 0s - loss: 0.6869" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "254/363 [===================>..........] - ETA: 0s - loss: 0.6898" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "307/363 [========================>.....] - ETA: 0s - loss: 0.6927" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "357/363 [============================>.] - ETA: 0s - loss: 0.6860" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.6853 - val_loss: 0.7792\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 29/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 1s - loss: 0.7584" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 52/363 [===>..........................] - ETA: 0s - loss: 0.6716" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "103/363 [=======>......................] - ETA: 0s - loss: 0.6857" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "154/363 [===========>..................] - ETA: 0s - loss: 0.6682" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "204/363 [===============>..............] - ETA: 0s - loss: 0.6785" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "254/363 [===================>..........] - ETA: 0s - loss: 0.6704" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "307/363 [========================>.....] - ETA: 0s - loss: 0.6766" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "357/363 [============================>.] - ETA: 0s - loss: 0.6779" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 0s 1ms/step - loss: 0.6791 - val_loss: 0.7426\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 30/30\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " 1/363 [..............................] - ETA: 0s - loss: 0.6178" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + " 49/363 [===>..........................] - ETA: 0s - loss: 0.7388" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "100/363 [=======>......................] - ETA: 0s - loss: 0.7004" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "153/363 [===========>..................] - ETA: 0s - loss: 0.6835" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "204/363 [===============>..............] - ETA: 0s - loss: 0.6809" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "254/363 [===================>..........] - ETA: 0s - loss: 0.6710" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "304/363 [========================>.....] - ETA: 0s - loss: 0.6687" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "356/363 [============================>.] - ETA: 0s - loss: 0.6747" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", + "363/363 [==============================] - 1s 1ms/step - loss: 0.6732 - val_loss: 0.7113\n" + ] + } + ], + "source": [ + "history = model.fit(X_train, y_train, epochs=30,\n", + " validation_data=(X_valid, y_valid),\n", + " callbacks=[checkpoint_cb, tensorboard_cb])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Visualisation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TensorBoard then needs to be run to visualise the logs. It simply runs in a browser.\n", + "\n", + "TensorBoard can be launched from your terminal by:\n", + "\n", + "```bash\n", + "tensorboard --logdir=./my_logs --port=6001\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then launch TensorBoard in a browser at [localhost:6001](http://localhost:6001)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's switch to TensorBoard to view the logs and inspect the computational graph of the model." + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "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.8.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}