Clase Nº 1
IA VS ML VS DL
Dentro de la inteligencia artificial tenemos
Machine Learning (ML): Las computadoras aprenden en base a experiencias pasadas, subconjunto de este esta el
Deep Learning (DL): Crear predicciones y clasificaciones basado en redes neuronales artificiales profundas (RNA) utilizando grandes conjuntos de datos el cerebro humano esta formado por miles de millones de neuronas que se comunican entre si medientes señales electricas.
Lo que diferencia el aprendizaje profundo de las tecnicas de aprendizaje de las maquinas es su capacidad para extraer características automaticamente
Procesos Machine Learning:
- 1. Seleccionar el modelo a entrenar
- 2. realizar manualmente la extracción de características.
Procesos Deep Learning:
- 1. Seleccionar la arquitectura de la red
- 2. las características se extraen automáticamente alimentando los datos de entrenamiento junto con la clase de objectivo.
Proyecto 1: Convertir Celsius a Fahrenheit.
En este proyecto, construiremos un simple modelo de aprendizaje de máquinas para convertir las temperaturas de Celsius a Fahrenheit.
La ecuación es la siguiente
T(ºF) = T(ºC) * (9/5) + 32
Ejemplo T(ºF) = (0ºC * 9/5) +32 = 32ºF
El objectivo es predecir el valor de una variable Y en base a otra variable X.
X se llama la variable independiente e Y se llama la variable dependiente
Esto se llama "Regresión" y se tratará con mucho mas a detalle.
Que son las Redes Neuronales Artificiales (RNA)
Son modelos de procesamiento de información inspirados en el cerebro humano. Donde tenemos un conjunto de entrenadas y nos devuelve un valor de salida.
vamos a ver cómo funcionan, tenemos el cerebro y la imagen de un gato, la imagen es un input y la funcion del cerebro es predecir que la imagen es un gato, cuando la imagen entra al cerebro (RNA) lo "correlaciona" con "experiencias pasadas" encuentra las características y reconoce. Mas el aprendizaje seria el siguiente, al analizar la imagen calcula cuando es correcto, si se equivocó o no y se genera una perdida (función de perdida) que crea una retroalimentación que se relaciona con una "Actualización de Pesos", todo pasa una y otra vez hasta que la neurona va reduciendo su funcion perdida.
Contruyamos la red más simple (Un modelo de una sola neurona)
Cargamos una lista con datos de entrenamiento (una tabla de Celsius a Fahrenheit)
Primero importamos la libreria tensorflow en python
import tensorflow as tf
la libreria panda que perdimite cargar el set de datos y trabajar con el en las sets de entrenamiento y prueba básicamente (base de datos y archivos)
import pandas as pd
la libreria numpy nos permite trabajar con matrices y matemátaicas.
import numpy as np
la libreria seaborn para hacer las visualizaciones de nuestro modelo.
import seaborn as sns
finalmente vamos a hacer splots de nuestro modelo para ver los gráficos con la libreria "matplotlib.pyplot"
import matploitlib.pyplot as plt
nota: en caso de no tener las librerias disponibles ejecutar el siguiente comando pip install nombre_de_la_libreria. continuamos
importamos el set de datos (base de datos) del set de entrenamiento
#Importando Datos
temperatura_df = pd.read_csv("celsius_a_fahrenheit.cvs")
el archivo "celsius_a_fahrenheit.cvs" es un documento abierto en excel con dos colummnas, la primera en Celsius (variable independiente) y la segunda en Fahrenheit (este set de datos puede crearse automaticamente usando una macro)
Celsius/Fahrenheit
**** / ****
**** / ****
**** / ****
**** / ****
...
...
...
**** / ****
a mayor cantidad de datos mejor sera en entrenamiento en este caso.
Para la visualización de datos
#visualizacion
sns.scatterplot(temperature_df['Celsius'],temperature_df['Fahrenheit'])
siguiente
#Cargando Set de Datos
X_train = temperature_df['Celsius']
y=train = temperature_df['Fahrenheit']
Creamos el modelo con tensorflow
#Creando el modelo
model = tf.keras.Sequential()
Sequential() significa que vamos a crear nuestro modelo capa por capa de manera "secuencial", recordemos que las neuronas tienen puntos de entrada tienen acciones dendritas sinapsis y todo eso hace a la neurona. entonces vamos a agregar, creamos la primera capa de nuestro modelo con la variable model agregamos la capa con el subcomando ".add()" y usamos el comando "tf.keras.layers"
model.add(tf.keras.layers.Dense(units=1, input_shape[1]))
la capa Dense es de las capaz mas simples, donde los parametros de entrada son "units" cantidad de neuronas en este caso nos basta con solo una e "input_shape" que el valor sera tambien 1.
Cuando trabajamos con IA debemos ver el modelo, con eso vemos la red antes de trabajar.
model.summary()
Las redes neuronales aprenden atravez de la funcion de perdida y ajustes de pesos (sesgos)
#Compilado
model.compile(optimizer=tf.keras.optimizers.Adam(0.5), loss='mean_squared_error')
En estadistica el error medio cuadrado es llamada desviación media cuadrada de un estimador mide el promedio de los cuadrados de los errores, es decir, la diferencia media cuadrada entre los valores estimados. El error medio cuadrado es una función de riesgo que corresponde al valor esperado de la perdida del error al cuadrado. Y lo que buscamos es la perdida del error para poder optimizar nuestra red.
Con lo anterior ya hemos compilado el modelo ahora nos falta una funcion que nos perdida entrena el modelo.
crear una funcion que nos perdima actualizar nuestros pesos corriendo atraves del set de datos para ajustar los pesos, por eso se cargo el set de datos en las variables X_train y y_train. llamos al modelo secuencia y le agregamos una neurona con la capa tipo Dense definiendo una neurona y una salida, compilamos el modelo en base a un optimizador y un modelo de errores.
Tenemos que crear una lista de epochs, el epochs es el numero de ciclos cuando se lee todo el set de entrenamiento.
#Entrenando el modelo
epochs_hist = model.fit(x_train, y_train, epochs = 100)
el entrenamiento dura realmente poco porque estamos trabajando con regresion lineal y porque el set de datos esta definido bajo un numero relativamente pequeño de entradas y salidas (recomendable ajustar la base de datos a 30 lineas en el excel)
cuando entrenamos el modelo veremos que la optimizacion del modelo esta basado en el valor "loss" a menor sea el valor mas exacto es el modelo.
nos interesa ver el historial de entrenamiento
#Evaluando modelo
epochs_hist.history.keys()
obtiene las llaves o claves del entrenamiento
#grafico
plt.plot(epochs_hist.history['loss'])
plt.title('Progreso de perdida durante el entrenamiento del modelo')
plt.xlabel('Epoch')
plt.ylabel('Training Loss')
plt.legends('Training Loss')
Lo anterior muestra la evolucion al modelo respecto a numero de ciclos de entrenamiento "epochs".
obtenemos los pesos del modelo
model.get_weights()
Ahora nos interesa hacer prediciones, comparamos el modelo con la ecuacion "ya que existe la formala determista" con eso evaluamos la exactitud del mismo.
#Predicciones
Temp_C = 0
temp_F = model.predict([Temp_C])
print(temp_F)
#formula
Temp_F = (9/5)*Temp_c + 32.
print(Temp_F)
y comparamos. para mejorar la prediccion podemos cambiar el modelo de compilado de 0.5 a 1
#Compilado
model.compile(optimizer=tf.keras.optimizers.Adam(1), loss='mean_squared_error')
Con lo anterior terminamos el modelo basico para iniciar con inteligencia artificial. E aqui el codigo fuente completo.
import tensorflow as tf
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
#impotando Datos
temperature_df = pd.read_csv("celsius_a_fahrenheit.csv")
#Visualizacion
sns.scatterplot(temperature_df['celsius'], temperature_df['fahrenheit'])
#Cargando Set de Datos
X_train = temperature_df['Celsius']
y_train = temperature_df['Fahrenheit']
#Creando el modelo
model = tf.keras.sequential()
model.add(tf.keras.layers.DEnse(units=1, input_shape=[1]))
model.summaryÇ()
#compilado
model.compile(optimizar=tf.keras.optimizers.Adam(1),loss='mean_squared_error')
#Entrenando el modelo
epochs_hist = model.fit(x_train, y_train, epochs=100)
#Evaluando modelo
epochs_hist.history.keys()
#gafico
plt.plot(epochs_hist.history['loss'])
plt.title('Progreso de perdida durante el entrenamiento del modelo')
plt.xlabel('Epoch')
plt.ylabel('Training Loss')
plt.legends('Training Loss')
model.get_weights()
#Predicciones
Temp_C = 0
temp_F = model.predict([Temp_C])
print(temp_F)
#formula
Temp_F = (9/5)*Temp_c + 32.
print(Temp_F)
Mostrar Mensajes
