Degrees_model.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Degrees model\n",
    "\n",
    "Here we develop a model to convert celsius degrees in fahrenheit degrees. The objetive behind this dummy model is to see how to implement different layers to our model and how effective those layers are. \n",
    "This results are useful to develop intuition and dig in how a neural network works and how machine learning is implemented."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We import principal packages.\n",
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We define the dataset we will use in the problem, in this case are two vectors\n",
    "# with inputs (celsius) and outputs (fahrenheit).\n",
    "celsius = np.array([-40,-10,0,8,15,22,38], dtype = float)\n",
    "fahrenheit = np.array([-40,14,32,46,59,72,100],dtype = float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remember that 'Dense' layers are those in which all neurons are interconnected.\n",
    "# In this case as we have only two neurons is a Dense layer.\n",
    "# We use Keras to indicate that output layer has a neuron throught 'units' command, \n",
    "# and we indicate that input layer has a neuron throught 'input_shape' command.\n",
    "capa = tf.keras.layers.Dense(units=1,input_shape=[1])\n",
    "\n",
    "# We use 'Sequential' model due to the simplicity of our problem.\n",
    "modelo = tf.keras.Sequential([capa])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We prepare model to execute.\n",
    "# We use Adam to adjust efficiently weights and bias, we indicate 0.1 as readjust rate\n",
    "# and MSE as loss function\n",
    "modelo.compile(\n",
    "    optimizer = tf.keras.optimizers.Adam(0.1), \n",
    "    loss = 'mean_squared_error'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting training...\n",
      "Model trained!\n"
     ]
    }
   ],
   "source": [
    "# We train the model\n",
    "print(\"Starting training...\")\n",
    "historial = modelo.fit(celsius,fahrenheit, epochs=1000, verbose = False)\n",
    "print(\"Model trained!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x22c87bee760>]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's see the training results\n",
    "import matplotlib.pyplot as plt\n",
    "plt.xlabel(\"# Epoch\")\n",
    "plt.ylabel(\"Loss magnitude\")\n",
    "plt.plot(historial.history[\"loss\"])\n",
    "\n",
    "# We can see how with ~500 epochs could be enought"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 81ms/step\n",
      "246 celsius throught our model is [[474.2917]] fahrenheit\n"
     ]
    }
   ],
   "source": [
    "# Let's make a prediction\n",
    "import random \n",
    "temp_pred = random.randint(-40, 300)\n",
    "resultado = modelo.predict([temp_pred])\n",
    "print(str(temp_pred), 'celsius throught our model is',str(resultado),\"fahrenheit\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inner variables of model\n",
      "[array([[1.7982856]], dtype=float32), array([31.913418], dtype=float32)]\n"
     ]
    }
   ],
   "source": [
    "# Let's see how model assigned weights and bias \n",
    "print('Inner variables of model')\n",
    "print(capa.get_weights())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now we add hidden layers to see how our model improve (or not).\n",
    "\n",
    "oculta1 = tf.keras.layers.Dense(units = 3, input_shape=[1])\n",
    "oculta2 = tf.keras.layers.Dense(units = 3)\n",
    "salida = tf.keras.layers.Dense(units = 1)\n",
    "modelo = tf.keras.Sequential([oculta1, oculta2, salida])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting training...\n",
      "Model trained!\n"
     ]
    }
   ],
   "source": [
    "modelo.compile(\n",
    "    optimizer = tf.keras.optimizers.Adam(0.1), \n",
    "    loss = 'mean_squared_error'\n",
    ")\n",
    "\n",
    "print(\"Starting training...\")\n",
    "historial = modelo.fit(celsius,fahrenheit, epochs=1000, verbose = False)\n",
    "print(\"Model trained!\")\n",
    "\n",
    "# Apreciate how the training time is higher"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x22c85d5ba90>]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.xlabel(\"# Epoch\")\n",
    "plt.ylabel(\"Loss magnitude\")\n",
    "plt.plot(historial.history[\"loss\"])\n",
    "\n",
    "# Here with only ~50 epochs we can see as it could be enought"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 159ms/step\n",
      "162 celsius throught our model is [[323.22028]] fahrenheit\n"
     ]
    }
   ],
   "source": [
    "import random \n",
    "temp_pred = random.randint(-40, 300)\n",
    "resultado = modelo.predict([temp_pred])\n",
    "print(str(temp_pred), 'celsius throught our model is',str(resultado),\"fahrenheit\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}