Skip to content

Instantly share code, notes, and snippets.

@marisbotero

marisbotero/-intro.ipynb

Last active July 17, 2020 14:21
Show Gist options
  • Save marisbotero/d9ee42e4ba5df38d5aa8011cd59dafe6 to your computer and use it in GitHub Desktop.
Save marisbotero/d9ee42e4ba5df38d5aa8011cd59dafe6 to your computer and use it in GitHub Desktop.
Download ZIP
馃挏Intro.ipynb
Display the source blob
Display the rendered blob
Raw
-intro.ipynb
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"name": "馃挏Intro.ipynb",
"provenance": [],
"include_colab_link": true
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"accelerator": "GPU"
},
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "view-in-github",
"colab_type": "text"
},
"source": [
"<a href=\"https://colab.research.google.com/gist/marisbotero/d9ee42e4ba5df38d5aa8011cd59dafe6/-intro.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "XNl94mckskzZ",
"colab_type": "text"
},
"source": [
"# **馃悕Hola Python Pereira**"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "q9UCcdFjkrsD",
"colab_type": "text"
},
"source": [
"## 馃挌Entrenando tu primer modelo馃挌\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_kucEXAh-PTF",
"colab_type": "text"
},
"source": [
"El problema que vamos a resolver es convertir de grados Celsius a Fahrenheit, donde la f贸rmula aproximada es:\n",
"\n",
"$$ f = c* 1.8 + 32 $$\n",
"\n",
"\n",
"Por supuesto, ser铆a bastante simple crear una funci贸n Python convencional que realice directamente este c谩lculo, pero eso no ser铆a Machine Learning\n",
"\n",
"En cambio, le daremos a TensorFlow algunos valores Celsius de muestra (0, 8, 15, 22, 38) y sus valores Fahrenheit correspondientes (32, 46, 59, 72, 100).Luego, entrenaremos un modelo que resuelva la f贸rmula anterior a trav茅s del proceso de entrenamiento.馃帀"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "7zkZOkxz_fBp",
"colab_type": "text"
},
"source": [
"## 猸怚mportar librerias\n",
"\n",
"馃挋Vamos a importar primero TensorFlow. Aqu铆, lo llamamos `tf` para facilitar su uso. Tambi茅n le decimos que solo muestre errores.\n",
"\n",
"\n",
"馃挏A continuaci贸n, importanos ([NumPy](http://www.numpy.org/)) como `np`. \n",
"Que nos ayuda a representar nuestros datos como listas de alto rendimiento."
]
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "bdLopQtuAJi4",
"colab": {}
},
"source": [
"# No importa esta declaraci贸n, por razones de compatibilidad.\n",
"from __future__ import absolute_import, division, print_function, unicode_literals"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "-ZMgCvSRFqxE",
"colab": {}
},
"source": [
"try:\n",
" # %tensorflow_version magic if in colab.\n",
" %tensorflow_version 2.x\n",
"except Exception:\n",
" pass\n",
"\n",
"import tensorflow as tf"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "y_WQEM5MGmg3",
"colab": {}
},
"source": [
"import numpy as np #numpy es una libreria para hacer operaciones matematicas de alto nivel\n",
"import logging #m贸dulo define funciones y clases que implementan un sistema flexible de registro de eventos para aplicaciones y bibliotecas.\n",
"logger = tf.get_logger()\n",
"logger.setLevel(logging.ERROR)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "MwrBNyKH__9_",
"colab_type": "text"
},
"source": [
"## 馃Configurar los datos de entrenamiento\n",
"\n",
"el aprendizaje autom谩tico supervisado se trata de descubrir un algoritmo dado un conjunto de entradas y salidas. Dado que la tarea en este Codelab es crear un modelo que pueda dar la temperatura en Fahrenheit cuando se dan los grados en Celsius, creamos dos listas `celsius_q` y` fahrenheit_a` que podemos usar para entrenar nuestro modelo."
]
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "gg4pn6aI1vms",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 140
},
"outputId": "1ff9004d-2d43-4279-8fcd-417a2544b2ea"
},
"source": [
"celsius_q = np.array([-40, -10, 0, 8, 15, 22, 38], dtype=float)\n",
"fahrenheit_a = np.array([-40, 14, 32, 46, 59, 72, 100], dtype=float)\n",
"\n",
"#Bucle para visualizar los datos de entrada y salida de nuestro modelo\n",
"for i,c in enumerate(celsius_q):\n",
" print(\"{} degrees Celsius = {} degrees Fahrenheit\".format(c, fahrenheit_a[i]))"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"text": [
"-40.0 degrees Celsius = -40.0 degrees Fahrenheit\n",
"-10.0 degrees Celsius = 14.0 degrees Fahrenheit\n",
"0.0 degrees Celsius = 32.0 degrees Fahrenheit\n",
"8.0 degrees Celsius = 46.0 degrees Fahrenheit\n",
"15.0 degrees Celsius = 59.0 degrees Fahrenheit\n",
"22.0 degrees Celsius = 72.0 degrees Fahrenheit\n",
"38.0 degrees Celsius = 100.0 degrees Fahrenheit\n"
],
"name": "stdout"
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Q0iKGpBEBW2j",
"colab_type": "text"
},
"source": [
"### 馃挏馃挏Alguna terminolog铆a de Machine Learning馃挏馃挏\n",
"\n",
"聽 - **Caracter铆stica** - La entrada (s) a de nuestro modelo. En este caso, un valor 煤nico: los grados en grados Celsius.\n",
"\n",
"聽 - **Etiquetas** - El resultado que predice de nuestro modelo. En este caso, un valor 煤nico: los grados en Fahrenheit.\n",
"\n",
"聽 - **Ejemplo** - Un par de entradas / salidas utilizadas durante el entrenamiento. En nuestro caso, un par de valores de `celsius_q` y` fahrenheit_a` en un 铆ndice espec铆fico, como `(22,72)`."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "PToGlfL0Bo55",
"colab_type": "text"
},
"source": [
"## 馃搳Creaci贸n del modelo\n",
"\n",
"utilizaremos el modelo m谩s simple posible, una red densa. Como el problema es sencillo, esta red requerir谩 solo una capa, con una sola neurona.\n",
"\n",
"### Construcci贸n de las capas\n",
"\n",
"Llamaremos a la capa `l0` y la crearemos instanciando` tf.keras.layers.Dense` con la siguiente configuraci贸n:\n",
"\n",
"* `input_shape = [1]` - Esto especifica que la entrada a esta capa es un valor 煤nico. Es decir, la forma es una matriz unidimensional con un miembro. Como esta es la primera (y 煤nica) capa, esa forma de entrada es la forma de entrada de todo el modelo. El valor 煤nico es un n煤mero de coma flotante, que representa grados Celsius.\n",
"\n",
"* `units = 1` - Esto especifica el n煤mero de neuronas en la capa. El n煤mero de neuronas define cu谩ntas variables internas tiene que tratar la capa para aprender a resolver el problema (m谩s adelante). Dado que esta es la capa final, tambi茅n es el tama帽o de la salida del modelo: un 煤nico valor flotante que representa grados Fahrenheit. (En una red de varias capas, el tama帽o y la forma de la capa tendr铆an que coincidir con la `input_shape` de la siguiente capa)."
]
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "pRllo2HLfXiu",
"colab": {}
},
"source": [
"l0 = tf.keras.layers.Dense(units=1, input_shape=[1])"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "BjSb-sNblvcL",
"colab_type": "text"
},
"source": [
"\n",
"**馃崁A menudo veras las capas definidas dentro de la definici贸n del modelo, en lugar de antes**:\n",
"\n",
"```python\n",
"model = tf.keras.Sequential([\n",
" tf.keras.layers.Dense(units=1, input_shape=[1])\n",
"])\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "EtcA8Sm_lI7r",
"colab_type": "text"
},
"source": [
"## 馃敤Ensamblar capas en el modelo\n",
"Una vez que se definen las capas, deben ensamblarse en un modelo. La definici贸n del modelo secuencial toma una lista de capas como argumento, especificando el orden de c谩lculo de la entrada a la salida.\n",
"\n",
"Este modelo tiene una sola capa, l0."
]
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "cSp-GpLSuMRq",
"colab": {}
},
"source": [
"model = tf.keras.Sequential([l0])"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "WOQ3o10lmMgJ",
"colab_type": "text"
},
"source": [
"## Compilar el modelo, con funciones de p茅rdida y optimizador\n",
"\n",
"Antes de entrenar, el modelo tiene que ser compilado. Cuando se compila para el entrenamiento, se debe tener presente:\n",
"\n",
"- **Funci贸n de p茅rdida** - Una forma de medir qu茅 tan lejos est谩n las predicciones del resultado deseado. (La diferencia medida se llama \"p茅rdida\").\n",
"\n",
"- **Funci贸n de optimizador** - Una forma de ajustar los valores internos para reducir la p茅rdida."
]
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "m8YQN1H41L-Y",
"colab": {}
},
"source": [
"model.compile(loss='mean_squared_error',\n",
" optimizer=tf.keras.optimizers.Adam(0.1))"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "WusKawMsolO7",
"colab_type": "text"
},
"source": [
"* durante el entrenamiento se usa (`model.fit ()`, a continuaci贸n) para calcular primero la p茅rdida en cada punto y luego mejorarla. De hecho, el acto de calcular la p茅rdida actual de un modelo y luego mejorarlo es precisamente lo que es el entrenamiento.\n",
"\n",
"* Durante el entrenamiento, la funci贸n de optimizaci贸n se usa para calcular los ajustes a las variables internas del modelo. El objetivo es ajustar las variables internas hasta que el modelo (que es realmente una funci贸n matem谩tica) refleje la ecuaci贸n real para convertir Celsius a Fahrenheit.\n",
"\n",
"* TensorFlow utiliza un an谩lisis num茅rico para realizar este ajuste, y toda esta complejidad est谩 oculta para nosotros, pero puede consultar la documentaci贸n oficial de la librer铆a. Lo que es 煤til saber sobre estos par谩metros son:\n",
"\n",
"馃挍 Funci贸n de p茅rdida ([mean squared error](https://en.wikipedia.org/wiki/Mean_squared_error)) y de optimiazci贸n ([Adam](https://machinelearningmastery.com/adam-optimization-algorithm-for-deep-learning/))utilizados aqu铆 son est谩ndar para modelos simples como este, pero hay muchos otros disponibles. \n",
"\n",
"馃АUna parte del Optimizador en la que se debe pensar al momento de crear sus propios modelos es la tasa de aprendizaje (`0.1` en el c贸digo anterior). Este es el tama帽o del paso dado al ajustar los valores en el modelo. Si el valor es demasiado peque帽o, se necesitar谩n demasiadas iteraciones para entrenar el modelo. Demasiado grande y la precisi贸n disminuye. Encontrar un buen valor a menudo implica alguna prueba y error, pero el rango generalmente est谩 dentro de 0.001 (predeterminado) y 0.1"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "dpyIoxEtqKGD",
"colab_type": "text"
},
"source": [
"## Entrenar al modelo\n",
"\n",
"para el entrenamiento se usa al m茅todo `fit`.\n",
"\n",
"Durante el entrenamiento, el modelo toma valores Celsius, realiza un c谩lculo utilizando las variables internas actuales (llamadas \"pesos\") y genera valores que est谩n destinados a ser el equivalente en Fahrenheit. Dado que los pesos se establecen inicialmente al azar, la salida no estar谩 cerca del valor correcto. La diferencia entre la salida real y la salida deseada se calcula utilizando la funci贸n de p茅rdida, y la funci贸n de optimizaci贸n dirige c贸mo deben ajustarse los pesos.\n",
"\n",
"Este ciclo de c谩lculo, comparaci贸n y ajuste se controla mediante el m茅todo `fit`. El primer argumento son las entradas, el segundo argumento son las salidas deseadas. El argumento `epochs` especifica cu谩ntas veces se debe ejecutar este ciclo, y el argumento`verbose` controla cu谩nta salida produce el m茅todo."
]
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "lpRrl7WK10Pq",
"colab": {}
},
"source": [
"history = model.fit(celsius_q, fahrenheit_a, epochs=500, verbose=False)\n",
"print(\"Finished training the model\")"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "cxP3zoBJwBj0",
"colab_type": "text"
},
"source": [
"## 馃枻Mostrar estad铆sticas de entrenamiento\n",
"\n",
"El m茅todo `fit` devuelve un objeto de historial. Podemos usar este objeto para trazar c贸mo la p茅rdida de nuestro modelo disminuye despu茅s de cada 茅poca de entrenamiento. Una p茅rdida alta significa que los grados Fahrenheit que predice el modelo est谩n lejos del valor correspondiente en `fahrenheit_a`.\n",
"\n",
"Usaremos [Matplotlib](https://matplotlib.org/) para visualizar el resultado. Podemos ver, que nuestro modelo que mejora muy r谩pidamente al principio, y luego tiene una mejora constante y lenta hasta que est谩 muy cerca de \"perfecto\" hacia el final."
]
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "IeK6BzfbdO6_",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 296
},
"outputId": "81ce9571-b443-4fc4-9e01-08991376fdea"
},
"source": [
"import matplotlib.pyplot as plt\n",
"plt.xlabel('Epoch Number')\n",
"plt.ylabel(\"Loss Magnitude\")\n",
"plt.plot(history.history['loss'])"
],
"execution_count": null,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7f0550181128>]"
]
},
"metadata": {
"tags": []
},
"execution_count": 14
},
{
"output_type": "display_data",
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEGCAYAAACUzrmNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de5zcdX3v8ddnZnZ39n7P5s4GCHJRrhFBra2giGiFVluwVqmHx0lPS494epW2j1Jt7dE+TqWlR6200EKrUqvykEMRiAGxtiokckkgYCJJyH2T7P2Svcx8zh+/72wmm93sZHdnZ3bn/Xw85jG/3/f3m998fmHZz34vv+/X3B0REZFTiRU6ABERKX5KFiIiMi0lCxERmZaShYiITEvJQkREppUodAD50NLS4u3t7YUOQ0RkQdm8efMRd2+d7NiiTBbt7e1s2rSp0GGIiCwoZrZ7qmNqhhIRkWkpWYiIyLSULEREZFpKFiIiMi0lCxERmZaShYiITEvJQkREpqVkkWV/9xCfe/wVdh4ZKHQoIiJFRckiS+fACHc9sYMdHf2FDkVEpKgoWWSpqYgeaO8fHi1wJCIixUXJIkt1JlkcGytwJCIixUXJIkttMkoWfcNKFiIi2ZQsslQkYiRixoCShYjICZQsspgZNcmEmqFERCZQspigpiKhZigRkQmULCaoqVDNQkRkIiWLCWqTCfpVsxAROUFek4WZ7TKzLWb2nJltCmVNZrbBzLaH98ZQbmZ2l5ntMLMXzOzSrOvcHM7fbmY35zPm6golCxGRieajZvF2d7/Y3deF/U8AG919LbAx7AO8G1gbXuuBL0KUXIA7gDcBlwN3ZBJMPqgZSkTkZIVohroeuC9s3wfckFV+v0d+CDSY2TLgXcAGd+909y5gA3BtvoJTM5SIyMnynSwceNzMNpvZ+lDW5u4HwvZBoC1srwD2ZH12byibqvwEZrbezDaZ2abDhw/POOAaNUOJiJwkkefrv9Xd95nZEmCDmb2cfdDd3cx8Lr7I3e8G7gZYt27djK9ZU1HG4EiKVNqJx2wuQhMRWfDyWrNw933hvQN4kKjP4VBoXiK8d4TT9wGrsj6+MpRNVZ4XNcnMZIKqXYiIZOQtWZhZtZnVZraBa4CtwENAZkTTzcC3wvZDwEfCqKgrgJ7QXPUYcI2ZNYaO7WtCWV7UVihZiIhMlM9mqDbgQTPLfM9X3P1RM3sG+JqZ3QLsBn45nP8IcB2wAxgEPgrg7p1m9mfAM+G8T7l7Z76C1syzIiIny1uycPdXgYsmKT8KXD1JuQO3TnGte4F75zrGyRxvhtKaFiIiGXqCe4LjCyClChyJiEjxULKYILOmhZqhRESOU7KYQEurioicTMligkyfRZ9qFiIi45QsJqgu19BZEZGJlCwmiMeMqvK4+ixERLIoWUyipiLBwIiShYhIhpLFJGqSCfVZiIhkUbKYRK1mnhUROYGSxSRqkloASUQkm5LFJLSmhYjIiZQsJlFdoT4LEZFsShaTUJ+FiMiJlCwmUZNMMDA8RjQRroiIKFlMoqaijLG0MzyWLnQoIiJFQcliEpofSkTkREoWk8gsrdp7TDPPioiAksWk6ipVsxARyaZkMYm6ZBkAfapZiIgAShaTqg3JondINQsREVCymFSmGUp9FiIiESWLSdSN1yyULEREQMliUlXlceIxUwe3iEigZDEJM6M2mVAzlIhIoGQxhbpkmZqhREQCJYsp1FUm6FUzlIgIoGQxpdqKMj1nISISKFlMoa4yoecsRESCvCcLM4ub2bNm9nDYX2NmPzKzHWb2r2ZWHsorwv6OcLw96xq3h/JXzOxd+Y4ZQp+FahYiIsD81CxuA7Zl7X8WuNPdzwa6gFtC+S1AVyi/M5yHmZ0P3ARcAFwLfMHM4vkOulYd3CIi4/KaLMxsJfAe4B/CvgFXAV8Pp9wH3BC2rw/7hONXh/OvBx5w92F33wnsAC7PZ9wQNUMNjKQYS2lNCxGRfNcs/hr4fSDzG7cZ6Hb3TGfAXmBF2F4B7AEIx3vC+ePlk3xmnJmtN7NNZrbp8OHDsw488xS3llcVEcljsjCz9wId7r45X9+Rzd3vdvd17r6utbV11terq9RkgiIiGYk8XvstwPvM7DogCdQBfwM0mFki1B5WAvvC+fuAVcBeM0sA9cDRrPKM7M/kTW1SkwmKiGTkrWbh7re7+0p3byfqoH7C3T8EPAl8IJx2M/CtsP1Q2Cccf8LdPZTfFEZLrQHWAk/nK+6M8ckElSxERPJas5jKHwAPmNmfA88C94Tye4B/NrMdQCdRgsHdXzSzrwEvAWPAre6eyneQ49OUqxlKRGR+koW7fxf4bth+lUlGM7n7MeCXpvj8p4FP5y/Ck6lmISJynJ7gnoLWtBAROU7JYgo1oYNba1qIiChZTCkeM2oqtKaFiAgoWZxSXVKTCYqIgJLFKdVVajJBERFQsjiluqTWtBARASWLU6pVM5SICJBDsrDIr5rZn4T91WaW91lfi4GaoUREIrnULL4AXAl8MOz3AZ/PW0RFJOrgVrIQEcnlCe43ufulZvYsgLt3ZVa3W+zqK8voGx4jlXbiMSt0OCIiBZNLzWI0rEznAGbWyvH1KRa1+qpy3FEnt4iUvFySxV3Ag8ASM/s08H3gL/IaVZFoCGtadA8qWYhIaZu2Gcrdv2xmm4GrAQNucPdt03xsUWisjpJF1+AI7VQXOBoRkcKZMlmYWVPWbgfw1exj7t6Zz8CKQX1l1DXTrU5uESlxp6pZbCbqpzBgNdAVthuA14A1eY+uwBqqoppFj5qhRKTETdln4e5r3P1M4DvAz7t7i7s3A+8FHp+vAAupsSqqWXQNjhQ4EhGRwsqlg/sKd38ks+Pu3wbenL+QikddmKZcHdwiUupyec5iv5n9MfAvYf9DwP78hVQ8EvEYtckEPeqzEJESl0vN4oNAK9Hw2QeBJRx/mnvRa6gqo1vNUCJS4nIZOtsJ3DYPsRSlxqpyutQMJSIlbtpkYWZPEp7ezubuV+UloiJTX1mmobMiUvJy6bP43aztJPB+oGTm7W6oKmdP52ChwxARKahcmqE2Tyj6TzN7Ok/xFJ3GKtUsRERyaYbKfpI7BlwG1OctoiLTUFlGz9CoZp4VkZKWSzNU9pPcY8BO4JZ8BlVMsmeebagqiZnZRUROkkuyOM/dj2UXmFlFnuIpOtkzzypZiEipyuU5i/+apOwHcx1IscrMPKt+CxEpZaeadXYpsAKoNLNLiJqhAOqAqnmIrShkZp7V/FAiUspO1Qz1LuDXgJXA57LK+4A/nO7CZpYEvgdUhO/5urvfYWZrgAeAZqL+kA+7+0ho2rqfqAP9KHCju+8K17qdqJ8kBXzM3R87jXucFc08KyJyimTh7vcB95nZ+939GzO49jBwlbv3m1kZ8H0z+zbw28Cd7v6Amf0dURL4Ynjvcvezzewm4LPAjWZ2PnATcAGwHPiOmZ3j7qkZxHTaMjPPasoPESllU/ZZmNmvhs12M/vtia/pLuyR/rBbFl4OXAV8PZTfB9wQtq8P+4TjV5uZhfIH3H3Y3XcCO4DLc7/F2RmfeVZ9FiJSwk7VwZ1ZR7QGqJ3kNS0zi5vZc0Qr7W0Afgp0u3vmCfC9RP0ihPc9AOF4D1FT1Xj5JJ/Ju8zMs5qmXERK2amaob4U3j8504uHpqKLzayBaMbac2d6remY2XpgPcDq1avn9NqaeVZESl0uT3C3Av8daM8+393/W65f4u7dYULCK4EGM0uE2sNKYF84bR+wCthrZgmip8SPZpVnZH8m+zvuBu4GWLdu3UkTH85GY1W5mqFEpKTl8pzFt4h+cX8H+Pes1ymZWWuoUWBmlcA7gW3Ak8AHwmk3h+sDPBT2CcefcHcP5TeZWUUYSbUWmNe5qeoryzRNuYiUtFye4K5y9z+YwbWXEY2mihMlpa+5+8Nm9hLwgJn9OfAscE84/x7gn81sB9BJNAIKd3/RzL4GvEQ03cit8zUSKqOlpoJdRwfm8ytFRIpKLsniYTO7Lnsd7ly4+wvAJZOUv8oko5nClCK/NMW1Pg18+nS+fy41VZdztF99FiJSunJphrqNKGEMmVmvmfWZWW++AysmzTXlDI6kGBwpmWU8REROkMt6FjkNk13MWqqjeROP9o9Q1ZRLZUxEZHHJZTTUpZMU9wC7s56XWNSaa6KnuI8OjLCqqWSmxRIRGZfLn8lfAC4FtoT9NwBbgXoz+w13fzxfwRWL5pqoZtE5MFzgSERECiOXPov9wCXufpm7XwZcDLxKNBT2L/MZXLForo5qFkfUyS0iJSqXZHGOu7+Y2XH3l4Bzw6imkjDeDKVkISIlKpdmqBfN7ItE04oD3Ai8FKYUL4kn1arKE1SWxTnar2YoESlNudQsfo1optePh9eroWwUeHu+Ais2zTXlHB1QzUJESlMuQ2eHgL8Kr4n6JylblJprKpQsRKRk5TJ0di3wv4HzgWSm3N3PzGNcRaelupyDvccKHYaISEHk0gz1j0Qr2Y0RNTvdD/xLPoMqRs01mvJDREpXLsmi0t03Aubuu939T4H35Des4tNUXcHRgWGiiXBFREpLLqOhhs0sBmw3s98iWkuiJr9hFZ+WmnJGU07vsTHqK8sKHY6IyLzKdSLBKuBjwGXAhzm+7kTJyDxr0alObhEpQbmMhnombPYDH81vOMWreXwywWHWtFRPc7aIyOIyZbIws4dO9UF3f9/ch1O8MjULTfkhIqXoVDWLK4E9wFeBHwE2LxEVqfGahSYTFJESdKpksZRossAPAr9CtO72V7PniSolTdWaH0pESteUHdzunnL3R939ZuAKoik/vhtGRJWc8kSMumRC80OJSEk6ZQd3mCzwPUS1i3bgLuDB/IdVnFprK9RnISIl6VQd3PcDrwceAT7p7lvnLaoi1VaX5JCm/BCREnSq5yx+FVhL9JzFf5lZb3j1mVnv/IRXXJbUVnCoT8lCRErPlDULd8/lgb2SEtUsoik/zEp6cJiIlBglhNOwpC7JyFianqGSWPNJRGScksVpaKuLnrU41KsRUSJSWpQsTkNbXbSchzq5RaTUTJsszKw6zDqLmZ1jZu8zs5KcdrWtVslCREpTLjWL7wFJM1sBPE406+w/5TOoYrUkNEN19KkZSkRKSy7Jwtx9EPhF4Avu/kvABfkNqzgly+LUJROqWYhIyckpWZjZlcCHiOaHAojn8KFVZvakmb1kZi+a2W2hvMnMNpjZ9vDemPkSM7vLzHaY2QtmdmnWtW4O5283s4KupdFWl6RDHdwiUmJySRYfB24HHnT3F83sTODJHD43BvyOu59PNLfUrWZ2PvAJYKO7rwU2hn2AdxM9BLgWWE+07jdm1gTcAbwJuBy4I5NgCqGtLslB1SxEpMRMmyzc/Sl3f5+7fzZ0dB9x94/l8LkD7v7jsN0HbANWANcD94XT7gNuCNvXA/d75IdAg5ktA94FbHD3TnfvAjYA157ebc6dpfVJDvYoWYhIacllNNRXzKzOzKqBrcBLZvZ7p/MlZtYOXEK0Lkabux8Ihw4CbWF7BdH6GRl7Q9lU5RO/Y72ZbTKzTYcPHz6d8E7L8oZKDvUdYzSVztt3iIgUm1yaoc53916iGsC3gTVEI6JyYmY1wDeAj4frjHN3Bzz3cKfm7ne7+zp3X9fa2joXl5zUioYk7qh2ISIlJZdkURaeq7gBeMjdR8nxF3z43DeAL7v7N0PxodC8RHjvCOX7gFVZH18ZyqYqL4jlDZUA7O8eKlQIIiLzLpdk8SVgF1ANfM/MzgCmnXXWopn27gG2ufvnsg49BGRGNN0MfCur/CNhVNQVQE9ornoMuMbMGkPH9jWhrCBWhGSxT8lCRErIKRc/AnD3u4gWPcrYbWZvz+HabyFqrtpiZs+Fsj8EPgN8zcxuAXYDvxyOPQJcR7Qi3yDw0fD9nWb2Z8Az4bxPuXtnDt+fF6pZiEgpmjZZmFk90dDVt4Wip4BPAT2n+py7fx+Yah7vqyc534Fbp7jWvcC908U6H5JlcZqry9nXrT4LESkduTRD3Qv0EdUAfpmoCeof8xlUsVveUKlmKBEpKdPWLICz3P39WfufzGpWKkkrGirZcbi/0GGIiMybXGoWQ2b21syOmb0FKOk/q5c3VLK/e4io5UxEZPHLpWbxP4D7Q98FQBfHRzOVpBWNlQyOpOgcGKG5pqLQ4YiI5F0u03087+4XARcCF7r7JcBVeY+siLU3VwGwu3OwwJGIiMyPnFfKc/ferCewfztP8SwIZzRXA7D76ECBIxERmR8zXVZ1qiGxJWFVUyVmsOuIahYiUhpmmixKume3IhFneX2lahYiUjKm7OA2sz4mTwoGVOYtogWivaVKfRYiUjKmTBbuXjufgSw0ZzRX8+jWg4UOQ0RkXsy0GarktTdX0TkwQs/QaKFDERHJOyWLGdKIKBEpJUoWM3RmS5QsfqppP0SkBChZzFB7SzVlceOVg0oWIrL4KVnMUFk8xlmtNfzkUF+hQxERyTsli1k4p62WVw4qWYjI4qdkMQvntNWwr3uIvmMaESUii5uSxSyc0xY9irK9Q/0WIrK4KVnMwuuWRsniJ2qKEpFFTsliFlY1VlFdHufF/b3TnywisoApWcxCLGa8YWU9z+/tLnQoIiJ5pWQxSxevamTbgV6OjaYKHYqISN4oWczSxasaGE05Lx1QU5SILF5KFrN08aoGAJ57TU1RIrJ4KVnM0tL6JEvrkjy7R8lCRBYvJYs5cPmaJn7w06O4l/QCgiKyiClZzIG3rm3hSP8wL+t5CxFZpJQs5sDPrG0B4PvbjxQ4EhGR/MhbsjCze82sw8y2ZpU1mdkGM9se3htDuZnZXWa2w8xeMLNLsz5zczh/u5ndnK94Z2NZfSVrl9Twve2HCx2KiEhe5LNm8U/AtRPKPgFsdPe1wMawD/BuYG14rQe+CFFyAe4A3gRcDtyRSTDF5m3ntPKjVzu1zKqILEp5Sxbu/j2gc0Lx9cB9Yfs+4Ias8vs98kOgwcyWAe8CNrh7p7t3ARs4OQEVhfddtJyRVJpvbzlQ6FBERObcfPdZtLl75rfpQaAtbK8A9mSdtzeUTVV+EjNbb2abzGzT4cPz3xx04cp6zmyp5pvP7pv37xYRybeCdXB7NM50zsaauvvd7r7O3de1trbO1WVzZmb8wiUreHpnJzuPDMz794uI5NN8J4tDoXmJ8N4RyvcBq7LOWxnKpiovSje+cRUViRhfeHJHoUMREZlT850sHgIyI5puBr6VVf6RMCrqCqAnNFc9BlxjZo2hY/uaUFaUltQl+eDlq/nms/vYfVS1CxFZPPI5dParwA+A15nZXjO7BfgM8E4z2w68I+wDPAK8CuwA/h74TQB37wT+DHgmvD4VyorWb/zcWSQTMX7/6y+QSuuJbhFZHGwxTlGxbt0637RpU8G+/9827eH3vv4Cv/6zZ/KJa8/FzAoWi4hIrsxss7uvm+xYYr6DKQUfuGwlP36tmy899Sqd/SP80XvOo6GqvNBhiYjMmJJFHpgZf/ELr6exqoy/e+qnPLr1IO84v42LVtZzTlstq5qqWFafJBHXbCsisjCoGSrPth3o5Z7v72TjtkN0DR5/ujsRM5Y3VHJGcxUXrWzgjWuaWHdGI9UVyt8iUhinaoZSspgn7k5H3zA7OvrZ0znIa52D7OkaYueRfrYd6COVdioSMd52TivXvWEpV5/XRl2yrNBhi0gJUZ9FETAz2uqStNUlTzo2MDzG5t1dPPFyB49uPciGlw5RHo8Sx89ftIyrz2ujRjUOESkg1SyKTDrtPLunm0e2HODfXzjAwd5jVCRiXHXuEt5z4TKuOncJVeVKHCIy99QMtUCl087m17p4+Pn9PLL1IIf7hqksi/PWtS28bW0LP7O2lTOaqzQ0V0TmhJLFIpBKO0/v7OTft+znu68cZm/XEACrmip5y1ktvLG9icvXNLGysVLJQ0RmRH0Wi0A8Zlx5VjNXntWMu7P76CD/sf0wT/3kCI9sOcADz0ST8y6tS/LGNU1c3t7IG9c0cc6SWmIxJQ8RmR0liwXIzGhvqaa9pZoPX9lOOu28cqiPZ3Z18vTOTp7eeZT/9/x+AOory1h3RpQ4Ll3dyIUr60mWxQt8ByKy0ChZLAKxmHHesjrOW1bHR65sx93Z0znE07s62bSrk6d3dbLx5WiC30TMuGB5HZesbuTSMxq57IxGltcn1XQlIqekPosScbR/mGdf62bza138eHcXL+ztYWg0BUBbXQWXndHIpasbuWR1I69fUUdFQrUPkVKjPguhuaaCd5zfxjvOjxYnHE2leflAHz9+rYsfv9bF5t1dPLLlIADl8RjnLa/jwhX1vGFlPReurOfs1hpNTyJSwlSzkHEdvcdC8ujm+T3dvLi/l/7hMQCSZTHOX1bHhSsbeMOKKIGc2VpDXJ3nIouGhs7KjKTTzs6jA2zZ28MLe3vYsi9KIIMjUfNVVXmc1y+v5/Ur6jlvWS3nLatjbVuNmrBEFig1Q8mMxGLGWa01nNVaww2XrACi5z1ePdwfkkcPL+zt5itP7+bYaBqIOtDPaq3h3JA8olctS2pPnuZERBYO1Sxk1lJpZ9fRAbYd6A2vPl4+0Mv+nmPj57TUlHPesjrOXVrLuUujGshZrTWaZVekiKhmIXkVz6qBvPfC5ePl3YMjbDvQN55EXj7Yx30/2M3IWHr8nBUNlZy9pIa1S2pY21bD2UtqOXtJDfWVmnFXpJgoWUjeNFSVjz91njGWSvNa5yDbO/rZ0dHP9kN9bO/o54evHmU4K4ksqa1gbVsNa5fUctaSGtY0V9PeUsXy+ko9kS5SAEoWMq8S8RhnttZwZmsN77rgeHkq7ezrGmJ7R5Q8th/qZ0dHH1/btGe8Qx2gPBHjjKYq2luqWdNSTXtIImtaqllap4cLRfJFyUKKQjxmrG6uYnVzFVef1zZe7u4c7D3GziMD7DoyyK6jA2F7gKdeOcxI6nhtJFkWi5JHczWrmipZ1VTFysZKVjVWsbKxispyjdISmSklCylqZsay+kqW1Vfy5rNOPJZKO/u7h9h1NEoeO0My+UlHH0+80nFC3whEnewrG0MCaaoKSSTaXt6Q1JBfkVNQspAFKx6z6Jd+UxU/s7b1hGPptHOkf5g9XUPs7Rpkb9cQezoH2dM1yJZ9PTy69SBj6RNHArbUlLO0PsnSukqW1SdZ1pBkWdb+0vqkJmGUkqVkIYtSLGYsqUuypC7JZWc0nnQ8lXYO9R5jT2eUSPZ1D3Gg5xgHe6Lk8syuTnqGRk/6XFN1OUvrkuPJY0ltktbaihNeLTXlqqXIoqNkISUpHjOWN1SyvKGSN01xzuDIGAd7jnGw5xj7QyI5EPYP9ERTo3QNnpxQIJoavrW2gtaa40lkyXgyqaCpupzmmnIaq8pVW5EFQclCZApV5YnxkVtTGRlLc3RgmMN9E179x7ef39tNR+/w+Cy/J39PnMaqcpqqj7+i/TIaq8tpqiqnsbqc5upyGqrKqa8sozyhSR1lfilZiMxCeSI23gE/nYHhsfFE0jkwMv7qGhihczC8D4zw6pF+ugZGxydxnEyyLEZ9ZRl1yTLqK6NXXeY9mTi+PV5WRn1VGbXJBNXlCU0AKadNyUJknlRXJKiuSNDeUp3T+cNjKboHRznaP0LXYEgsgyP0Do3Se2yMnsFReoZG6T02ysHeY/yko4+ewVH6hseYbhafqvI41RUJakNM1RVxairKqKmIymvCa3w7mdmOjleWxaNXefSu6esXvwWTLMzsWuBvgDjwD+7+mQKHJJJXFYk4bXVx2upObxLGdNrpGx6jdygkk5BQou0x+ofHGBgeY2BkjP7hFP3HRhkYTrG/e2j8WP/w2AlP1E+nLG4nJI9kWZyq8kn2y+Ikw3tVeVReHo9RURajInF8O3qfuB+jIh4f39eT/PNrQSQLM4sDnwfeCewFnjGzh9z9pcJGJlJ8YjEbb5paNYvrjKbS44ljYDhF//Ao/cMpBobHODaaYnAkxbHRFEMjKYay9ycc6xoYPaF8aDR10jMwM1EWtyjBJGJUJGInvCdiUUJJxI1EPEZZzCgL+2XxGImYUZaIyhOhvDwefS46x0jEYiecU5b92ZCsEjEjZkY8ZsRjELPoc7FYNIgibjbJeXbCscx2pjxmFOVMBAsiWQCXAzvc/VUAM3sAuB5QshDJk7J4jIaqqFN9rqXSPp5ARsbSDI+lw/vx/RO3Jz/npM+MphlJpRkNr5GxNAMjKcbC/ljKGU2H95SHsjSj6Wi7WCbhjhlTJpVYSCgxixJQLJa1bfD21y3hj997/pzHtFCSxQpgT9b+XjhxxKOZrQfWA6xevXr+IhOR0xaP2XgfTjFJhaQxlnbGUlHiGUv5eJIZTzipNGl3UmkYS6dJpyHlTjrtpNLOWNrD8eh9LOXHj4f3sfTx46k0OZ7npD2aBueEbY+20+4sa5h+sMVMFNd/qVlw97uBuyFaz6LA4YjIAhT9Na/nXiazUIYw7IMTml9XhjIREZkHCyVZPAOsNbM1ZlYO3AQ8VOCYRERKxoJohnL3MTP7LeAxoqGz97r7iwUOS0SkZCyIZAHg7o8AjxQ6DhGRUrRQmqFERKSAlCxERGRaShYiIjItJQsREZmWebE83z6HzOwwsHsWl2gBjsxROAuF7rk06J5Lw0zv+Qx3b53swKJMFrNlZpvcfV2h45hPuufSoHsuDfm4ZzVDiYjItJQsRERkWkoWk7u70AEUgO65NOieS8Oc37P6LEREZFqqWYiIyLSULEREZFpKFlnM7Foze8XMdpjZJwodz1wxs3vNrMPMtmaVNZnZBjPbHt4bQ7mZ2V3h3+AFM7u0cJHPnJmtMrMnzewlM3vRzG4L5Yv2vs0saWZPm9nz4Z4/GcrXmNmPwr39a5jmHzOrCPs7wvH2QsY/G2YWN7NnzezhsL+o79nMdpnZFjN7zsw2hbK8/mwrWQRmFgc+D7wbOB/4oJnN/UK2hfFPwLUTyj4BbHT3tcDGsA/R/a8Nr/XAF+cpxrk2BvyOu58PXAHcGv57Lub7HgaucveLgIuBa83sCuCzwJ3ufjbQBdwSzr8F6Arld4bzFqrbgG1Z+6Vwz29390VIt3cAAAVcSURBVIuznqfI78+2u+sVdfJfCTyWtX87cHuh45rD+2sHtmbtvwIsC9vLgFfC9peAD0523kJ+Ad8C3lkq9w1UAT8mWqv+CJAI5eM/50Trw1wZthPhPCt07DO415Xhl+NVwMOAlcA97wJaJpTl9WdbNYvjVgB7svb3hrLFqs3dD4Ttg0Bb2F50/w6hqeES4Ecs8vsOzTHPAR3ABuCnQLe7j4VTsu9r/J7D8R6geX4jnhN/Dfw+kA77zSz+e3bgcTPbbGbrQ1lef7YXzOJHkj/u7ma2KMdQm1kN8A3g4+7ea2bjxxbjfbt7CrjYzBqAB4FzCxxSXpnZe4EOd99sZj9X6Hjm0VvdfZ+ZLQE2mNnL2Qfz8bOtmsVx+4BVWfsrQ9lidcjMlgGE945Qvmj+HcysjChRfNndvxmKF/19A7h7N/AkURNMg5ll/jDMvq/xew7H64Gj8xzqbL0FeJ+Z7QIeIGqK+hsW9z3j7vvCewfRHwWXk+efbSWL454B1oZRFOXATcBDBY4pnx4Cbg7bNxO16WfKPxJGUFwB9GRVbRcMi6oQ9wDb3P1zWYcW7X2bWWuoUWBmlUR9NNuIksYHwmkT7znzb/EB4AkPjdoLhbvf7u4r3b2d6P/ZJ9z9QyziezazajOrzWwD1wBbyffPdqE7aorpBVwH/ISonfePCh3PHN7XV4EDwChRe+UtRO20G4HtwHeApnCuEY0K+ymwBVhX6PhneM9vJWrXfQF4LryuW8z3DVwIPBvueSvwJ6H8TOBpYAfwb0BFKE+G/R3h+JmFvodZ3v/PAQ8v9nsO9/Z8eL2Y+V2V759tTfchIiLTUjOUiIhMS8lCRESmpWQhIiLTUrIQEZFpKVmIiMi0lCxk0TOzVJidM/OasxmFzazdsmbzPcV5f2pmg+GJ20xZ/3zGIDIbmu5DSsGQu19c6CCIJq37HeAPCh1INjNL+PF5lEQmpZqFlKywJsBfhnUBnjazs0N5u5k9Eeb+32hmq0N5m5k9GNaLeN7M3hwuFTezv7doDYnHw9PTk7kXuNHMmibEcULNwMx+18z+NGx/18zuNLNNZrbNzN5oZt8Maxb8edZlEmb25XDO182sKnz+MjN7Kkw491jWdBDfNbO/tmgthNtm/68pi52ShZSCygnNUDdmHetx9zcA/5do9lKAvwXuc/cLgS8Dd4Xyu4CnPFov4lKip2chWifg8+5+AdANvH+KOPqJEsbp/nIe8WjNgr8jmsLhVuD1wK+ZWWbG1NcBX3D384Be4DfD3Fh/C3zA3S8L3/3prOuWu/s6d/+r04xHSpCaoaQUnKoZ6qtZ73eG7SuBXwzb/wz8Zdi+CvgIjM/u2mPRamQ73f25cM5morVDpnIX8JyZ/Z/TiD8zR9kW4EUP8/qY2atEE8R1A3vc/T/Def8CfAx4lCipbAiz7caJpn3J+NfTiEFKnJKFlDqfYvt0DGdtp4CpmqFw924z+wpR7SBjjBNr+ckprp+e8F1pjv8/PDF2J5oT6EV3v3KKcAamilNkIjVDSam7Mev9B2H7v4hmMAX4EPAfYXsj8BswvshQ/Qy/83PAr3P8F/0hYImZNZtZBfDeGVxztZllksKvAN8nWhGtNVNuZmVmdsEMY5YSp2QhpWBin8Vnso41mtkLRP0I/yuU/U/go6H8wxzvY7gNeLuZbSFqbprRGu3ufoRoDYKKsD8KfIpoFtQNwMtTf3pKrxCtM74NaAS+6O4jRNNwf9bMnieaeffNp7iGyJQ066yUrLBgzrrwy1tETkE1CxERmZZqFiIiMi3VLEREZFpKFiIiMi0lCxERmZaShYiITEvJQkREpvX/AQG/P7555FZIAAAAAElFTkSuQmCC\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"tags": [],
"needs_background": "light"
}
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Pcue0k0QxbIr",
"colab_type": "text"
},
"source": [
"Usa el modelo para predecir valores\n",
"Ahora tiene un modelo que ha sido entrenado para aprender la relaci贸n entre celsius_q y fahrenheit_a. Puede usar el m茅todo de predicci贸n para que calcule los grados Fahrenheit para grados Celsius previamente desconocidos.\n",
"\n",
"Entonces, por ejemplo, si el valor Celsius es 100, 驴cu谩l cree que ser谩 el resultado Fahrenheit? Adivina antes de ejecutar este c贸digo."
]
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "oxNzL4lS2Gui",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 34
},
"outputId": "a50eb429-a72f-46b6-bf8f-babfa8ec0917"
},
"source": [
"print(model.predict([100.0]))"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"text": [
"[[211.29968]]\n"
],
"name": "stdout"
}
]
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "XcBP6zi1ybCg",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 34
},
"outputId": "11806dff-f8a5-48c2-c5ec-9c8d92927afd"
},
"source": [
"print(model.predict([200.0]))"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"text": [
"[[393.86972]]\n"
],
"name": "stdout"
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "91NBQ5ICykMV",
"colab_type": "text"
},
"source": [
"La respuesta correcta es $100 \\times 1.8 + 32 = 212$, por lo que nuestro modelo est谩 funcionando muy bien.\n",
"\n",
"### Para revisar\n",
"\n",
"* Creamos un modelo con una capa densa\n",
"* Lo entrenamos con 3500 ejemplos (7 pares, m谩s de 500 茅pocas).\n",
"\n",
"Nuestro modelo ajust贸 las variables (pesos) en la capa Densa hasta que pudo devolver el valor Fahrenheit correcto para cualquier valor Celsius. (Recuerda, 100 Celsius no era parte de nuestros datos de entrenamiento)."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "OXeMnOdAzygu",
"colab_type": "text"
},
"source": [
"馃挍\n",
"Miremos los pesos de las capas\n",
"Finalmente, imprimamos las variables internas de la capa Densa."
]
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "kmIkVdkbnZJI",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 34
},
"outputId": "54489e77-6d63-4e83-dcf5-2db59221caeb"
},
"source": [
"print(\"These are the layer variables: {}\".format(l0.get_weights()))"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"text": [
"These are the layer variables: [array([[1.8257002]], dtype=float32), array([28.729662], dtype=float32)]\n"
],
"name": "stdout"
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CjzSpz4L0vYO",
"colab_type": "text"
},
"source": [
"La primera variable est谩 cerca de ~1.8 y la segunda a ~32. Estos valores (1.8 y 32) son las variables reales en la f贸rmula de conversi贸n real.\n",
"\n",
"Esto est谩 muy cerca de los valores en la f贸rmula de conversi贸n. pero para una sola neurona con una sola entrada y una sola salida, la matem谩tica interna se ve igual que la ecuaci贸n para una l铆nea, y = mx + b , que tiene la misma forma que la ecuaci贸n de conversi贸n, f = 1.8c + 32.\n",
"\n",
"Como la forma es la misma, las variables deber铆an converger en los valores est谩ndar de 1.8 y 32, que es exactamente lo que sucedi贸.\n",
"\n",
"Con neuronas adicionales, entradas adicionales y salidas adicionales, la f贸rmula se vuelve mucho m谩s compleja, pero la idea es la misma."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "J7j_uLYF1QZ-",
"colab_type": "text"
},
"source": [
"## Un peque帽o experimento\n",
"\n",
"驴qu茅 pasa si creamos m谩s capas densas con diferentes unidades, que por lo tanto tambi茅n tienen m谩s variables?"
]
},
{
"cell_type": "code",
"metadata": {
"colab_type": "code",
"id": "Y2zTA-rDS5Xk",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 263
},
"outputId": "85c9845e-f96f-45e3-a93d-21d3505322ab"
},
"source": [
"l0 = tf.keras.layers.Dense(units=4, input_shape=[1])\n",
"l1 = tf.keras.layers.Dense(units=4)\n",
"l2 = tf.keras.layers.Dense(units=1)\n",
"model = tf.keras.Sequential([l0, l1, l2])\n",
"model.compile(loss='mean_squared_error', optimizer=tf.keras.optimizers.Adam(0.1))\n",
"model.fit(celsius_q, fahrenheit_a, epochs=500, verbose=False)\n",
"print(\"modelo Entrenado\")\n",
"print(model.predict([100.0]))\n",
"print(\"El modelo predice que 100 grados Celsius es: {} degrees Fahrenheit\".format(model.predict([100.0])))\n",
"print(\"Estas son las variables l0: {}\".format(l0.get_weights()))\n",
"print(\"Estas son las variables l1: {}\".format(l1.get_weights()))\n",
"print(\"Estas son las variables l2: {}\".format(l2.get_weights()))"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"text": [
"modelo Entrenado\n",
"[[211.74744]]\n",
"El modelo predice que 100 grados Celsius es: [[211.74744]] degrees Fahrenheit\n",
"Estas son las variables l0: [array([[-0.48331484, -0.26425937, 0.27393183, 0.35009843]],\n",
" dtype=float32), array([-3.3172476, 2.1680315, 3.352336 , 3.1641006], dtype=float32)]\n",
"Estas son las variables l1: [array([[ 1.0073822 , 1.0120987 , -0.39548022, -0.2694926 ],\n",
" [-0.1821391 , -0.1327263 , 1.197555 , 0.98735654],\n",
" [-0.8868927 , -0.58175534, 0.33293673, 0.6419989 ],\n",
" [-1.3141623 , 0.05242901, -0.14548413, 0.9013979 ]],\n",
" dtype=float32), array([-3.4697073, -0.7854123, 0.4618529, 3.5536973], dtype=float32)]\n",
"Estas son las variables l2: [array([[-1.2423879 ],\n",
" [-0.17954892],\n",
" [ 0.12979956],\n",
" [ 0.78609097]], dtype=float32), array([3.2585516], dtype=float32)]\n"
],
"name": "stdout"
}
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ppbJ-clw1msE",
"colab_type": "text"
},
"source": [
"este modelo tambi茅n puede predecir el valor Fahrenheit correspondiente realmente bien. Pero cuando observa las variables (pesos) en las capas l0 y l1, ni siquiera se acercan a ~ 1.8 y ~ 32. La complejidad a帽adida oculta la forma \"simple\" de la ecuaci贸n de conversi贸n.\n"
]
}
]
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment