logongas

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
====== 8. Optimización de redes neuronales ======


===== Sobreajuste  =====
El sobreajuste (en inglés Overfitting) es cuando nuestro modelo, en vez de aprender lo que hace es memorizar los resultados. Tambien existe el concepto de subajuste (en inglés underfitting) que es cuando el modelo no es lo suficientemente ponente para adecuarse a los datos. En redes neuronales suele darse menos el underfitting ya que las redes las podemos haces bastantes complejos y solemos pecar de modelos demasiado complejos.

En las siguientes gráficas se observas distintos redes neuronales que tienen sobreajuste:

{{:clase:iabd:pia:2eval:sobreajuste.png?1000|}}

El sobreajuste se ve porque la red aprende cada vez más en entrenamiento pero aprende cada vez menos en validación. Es decir, disminuye la perdida en entrenamiento pero no disminuye en validación.

¿Como podemos evitar el sobre ajuste? Hay varias formas:
  * Dropout
  * Regularización


==== Regularización ====
Para hacer el modelo mas sencillo, la regularización intenta que los pesos sean mas pequeños. En una red neuronal tenemos una serie de pesos ''w'' y ''b''. Si penalizamos la función de pérdida cuando los pesos son mas grandes, habremos "hecho" la regularización. 

Se consigue que el tener el ''w'' o ''b'' muy bajo esa neurona "no exista" y por lo tanto simplifica el modelo. Un modelo más sencillo hace que haya menos sobre ajuste.

Existen 3 tipos de regularizadores (realmente existen más):
  * ''L1'': También llamada //Lasso//. Intenta hacer los pesos lo más pequeños posibles.
  * ''L2'': También llamada //Ridge//. Intenta eliminar correlaciones entre pesos.
  * ''L1L2'': También llamada //ElasticNet//. Es la unión de los 2 anteriores.

Los regularizadores se pueden aplicar tanto a los ''w'' como a los ''b'':
  * ''kernel_regularizer'': Para aplicarse a los ''w''
  * ''bias_regularizer'': Para aplicarse a los ''b''

<note tip>Lo normal es aplicar los regularizadores a los ''w'' es decir usar ''kernel_regularizer''.</note>

Ejemplos de uso en Keras de ''L1'':
<sxh python>
from tensorflow.keras import regularizers

kernel_regularizer=regularizers.L1(l1=0.01)
kernel_regularizer="l1"
model.add(Dense(neuronas_capa, activation=activation,kernel_regularizer=kernel_regularizer))
</sxh>

Ejemplos de uso en Keras de ''L2'':
<sxh python>
from tensorflow.keras import regularizers

kernel_regularizer=regularizers.L2(l2=0.01)
kernel_regularizer="l2"
model.add(Dense(neuronas_capa, activation=activation,kernel_regularizer=kernel_regularizer))
</sxh>

Ejemplos de uso en Keras de ''L1L2'':
<sxh python>
from tensorflow.keras import regularizers

kernel_regularizer=regularizers.L1L2(l1=0.01, l2=0.01)
kernel_regularizer="l1_l2"
model.add(Dense(neuronas_capa, activation=activation,kernel_regularizer=kernel_regularizer))
</sxh>

Los valores de ''l1'', ''l2'' que se pasa a los regularizadores es la tasa de regularización o cantidad de regularización y es cuanto queremos que regularicemos. Si vale 0, no se regulariza nada. Si vale 1 se regulariza muchísimo.

<note>
Como vemos el regularizador se puede indicar creando la clase para indicar el nivel de regularización o simplemente con un string e indicando el nombre.
</note>

Vamos a ver como funcionan los distintos regularizadores y con distintos valores:

{{:clase:iabd:pia:2eval:regularizacion_exp.png?1000|}} 


En la siguiente gráfica vamos a mostrar el valor de la pérdida en la última época en función del nivel de regularización:

{{:clase:iabd:pia:2eval:regularizacion_vs_loss_exp.png|}}

Más información:
  * [[https://www.tensorflow.org/api_docs/python/tf/keras/regularizers|Module: tf.keras.regularizers]]
  * [[https://www.iartificial.net/regularizacion-lasso-l1-ridge-l2-y-elasticnet/|Regularización Lasso L1, Ridge L2 y ElasticNet]]: Fórmulas de L1, L2 y ElasticNet
  * [[http://laid.delanover.com/difference-between-l1-and-l2-regularization-implementation-and-visualization-in-tensorflow/|Difference between L1 and L2 regularization, implementation and visualization in Tensorflow]]: Las imágenes en 3D de las 2 regularizaciones.
  * [[https://explained.ai/regularization/impl.html|How we express regularization in practice]]: Mas imágenes en 3D de L1 y L2
  * [[https://ichi.pro/es/intuiciones-sobre-la-regularizacion-l1-y-l2-38891695686241|Intuiciones sobre la regularización L1 y L2]]: Explica gracias a las derivadas porque L1 hace que el peso sea menor.
  * [[https://rorasa.wordpress.com/2012/05/13/l0-norm-l1-norm-l2-norm-l-infinity-norm/|l0-Norm, l1-Norm, l2-Norm, … , l-infinity Norm]]: Las normas (de matemáticas) que se usan en L1 y L2.
  * [[https://codatalicious.medium.com/regularization-1a186c620598|Regularization]]
  * [[https://towardsdatascience.com/machine-learning-regularization-techniques-in-real-life-your-dogs-nap-time-as-a-regularized-9c533510fe83|Machine Learning regularization techniques in real life]]
  * [[https://medium.com/nerd-for-tech/lasso-and-ridge-regularization-simply-explained-d551ee1e47b7|LASSO and Ridge Regularization .. Simply Explained]]
  * [[https://www.linkedin.com/pulse/l1-l2-regularization-why-neededwhat-doeshow-helps-ravi-shankar/|L1, L2 Regularization – Why needed/What it does/How it helps?]]
  * [[https://www.linkedin.com/pulse/bias-variance-tradeoff-what-why-important-ravi-shankar|Bias-Variance Tradeoff: What is it and why is it important?]]
  * {{ :clase:iabd:pia:regulation_techniques_for_multicollinearity-lasso_ridge_and_elastic_nets.pdf |Regulation Techniques for Multicollinearity: Lasso, Ridge, and Elastic Nets}}
  * [[https://stats.stackexchange.com/questions/151304/why-is-ridge-regression-called-ridge-why-is-it-needed-and-what-happens-when|Why is ridge regression called "ridge", why is it needed, and what happens when λ goes to infinity?]]
  * {{ :clase:iabd:pia:2eval:shrinkage_ridge_regression_subset_selection_and_lasso.pdf |}}
  * [[https://ichi.pro/es/de-la-regresion-lineal-a-la-regresion-de-crestas-el-lazo-y-la-red-elastica-86512636393446|De la regresión lineal a la regresión de crestas, el lazo y la red elástica]]: Están las gráficas de L1, L2 pero también L1+L2
  * [[https://medium.com/analytics-vidhya/logistic-regression-a3249301b75e|Logistic Regression]]: Explica cosas de L1 y L2
  * [[https://www.youtube.com/watch?v=MgEp4Gb9TCA|No Todas las Bolas Son Redondas | Cuando π ≠ 3,14...]]
  * [[https://salvatore-raieli.medium.com/a-complete-guide-to-linear-regression-using-gene-expression-data-regularization-f980ba6b11f7|A complete guide to linear regression using gene expression data: regularization]]


==== Dropout ====
El Dropout consiste en hacer que ciertas neuronas se vayan desactivando cada vez en el **entrenamiento**. 

Se hace añadiendo capas de ''Dropout'' con una tasa (''rate'') de cuantas neuronas se desactivan. Un valor de 0 es como si no hubiera dropout y un valor cercano a 1 es como si se desactivaran la mayoría de neuronas. (No se permite el valor de 1)

Uso de uso en Keras de Dropout:
<sxh python>
from tensorflow.keras.layers import Dropout

dropout_rate=0.02
model.add(Dense(neuronas_capa, activation=activation))
model.add(Dropout(rate=dropout_rate))
</sxh>

{{:clase:iabd:pia:2eval:dropout_exp.png?1000|}}


===== Optimización =====
Junto con las técnicas anteriores , existen otras para mejorar una red neuronal:
  * Normalization 
  * Tamaño de Batch
  * Parada anticipada


==== Normalization ====
La normalización consiste es que los datos de entrada estén centrado en 0 y una desviación "pequeña". 
Esto se hace porque la red va a entrenarse mejor si los datos son "pequeños" y todos en la misma escala ya que así funciona mejor el algoritmo del descenso de gradiente.

Para normalizar los datos se usa la clase [[https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html|StandardScaler]] de sklearn.



<sxh python>
from sklearn.preprocessing import StandardScaler

standard_scaler = StandardScaler()
standard_scaler.fit(x)
x_standard = standard_scaler.transform(x)
</sxh>

Y sobre un ejemplo de datos sería lo siguiente:
<sxh python>
def get_datos_bread_cancer():
    datos=load_breast_cancer()
    x=datos.data
    y=datos.target

    standard_scaler = StandardScaler()
    standard_scaler.fit(x)
    x = standard_scaler.transform(x)

    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42,stratify=y)

    state={ 
        "mean":standard_scaler.mean_,
        "var":standard_scaler.var_,
        "scale":standard_scaler.scale_
    }

    return x_train, x_test, y_train, y_test, state



x_train, x_test, y_train, y_test,state=get_datos_bread_cancer() 
</sxh>


Veamos un ejemplo de que es lo que realmente hace.
<sxh python>
from sklearn.preprocessing import StandardScaler

datos=np.random.normal(1000,50,5000).reshape(-1,1)

figure=plt.figure(figsize = (6, 9))
axes = figure.add_subplot(3,1,1)
sns.histplot(x=datos.reshape(-1),ax=axes)

standard_scaler = StandardScaler()
standard_scaler.fit(datos)

datos_standarized = standard_scaler.transform(datos)
axes = figure.add_subplot(3,1,2)
sns.histplot(x=datos_standarized.reshape(-1),ax=axes)
figure.suptitle("StandardScaler", fontsize=22, color='#003B80')
</sxh>

{{:clase:iabd:pia:2eval:standard_scaler.png|}}


Un problema que hay al usar la clase ''StandardScaler'' es que en producción hay que usar la misma transformación para predecir los datos. Por ello es necesario guardar los datos de la clase para volver a ponerlos.

La forma de hacerlo es la siguiente:
<sxh python>
state={ 
    "mean":standard_scaler.mean_,
    "var":standard_scaler.var_,
    "scale":standard_scaler.scale_
}
new_standard_scaler = StandardScaler()
new_standard_scaler.fit([[0]])
new_standard_scaler.mean_=state["mean"]
new_standard_scaler.var_=state["var"]
new_standard_scaler.scale_=state["scale"]
new_datos_standarized = new_standard_scaler.transform(datos)

print("Iguales=",np.array_equal(datos_standarized,new_datos_standarized))
</sxh>


<sxh base>
Iguales= True
</sxh>

==== Batch Normalization ====
Hace que las salida sigan con valores alrededor de media 0 y desviación 1.

<sxh python>
model.add(Dense(neuronas_capa, activation=activation))
model.add(BatchNormalization())
</sxh>

==== Tamaño del Batch  ====
<sxh python>
history=model.fit(x_train,y_train,validation_data=(x_test,y_test),epochs=40,verbose=False,batch_size=20)
</sxh>


<sxh python>
def fit(x, y_true,epochs,batch_size,learning_rate,w_2,w_3,w_4,w_52,w_53,w_54,b_2,b_3,b_4,b_5):
    #Divide los datos en batchs
    x_batchs=np.split(x, np.arange(batch_size,len(x),batch_size))
    y_true_batchs=np.split(y_true, np.arange(batch_size,len(y_true),batch_size))
    num_batchs=len(x_batchs)

    for epoch in range(epochs):
        for i in range(num_batchs):

            x_batch=x_batchs[i]
            y_true_batch=y_true_batchs[i]

            w_2,w_3,w_4,w_52,w_53,w_54,b_2,b_3,b_4,b_5=descenso_gradiente(x_batch,y_true_batch,learning_rate,w_2,w_3,w_4,w_52,w_53,w_54,b_2,b_3,b_4,b_5)   

    return w_2,w_3,w_4,w_52,w_53,w_54,b_2,b_3,b_4,b_5
</sxh>

  * [[https://machinelearningmastery.com/difference-between-a-batch-and-an-epoch/|Difference Between a Batch and an Epoch in a Neural Network]]


==== Parada anticipada ====
La parada anticipada resuelve el problema de cuántas épocas debemos entregar nuestro modelo. Lo que hace es detener el entrenamiento si la métrica no mejora. Para ello se usa la clase de callback de keras llamado ''EarlyStopping()''.

La clase contiene entre otros los siguientes parámetros:
  * ''monitor'': La métrica a monitorizar. Por defecto monitoriza ''val_loss''.
  * ''min_delta'': El mínimo valor que consideramos como una mejora. Si mejora menos que este valor lo consideraremos como que no ha mejorado. Por defecto si valor es 0.
  * ''patience'': Cuántas épocas puede estar sin mejorar antes de que paremos el entrenamiento. Por defecto vale 0.
  * ''mode'': Indica el tipo de métrica que es. Es decir si la métrica es mejor cuanto mayor valor tiene (''max'') o la métrica es mejor cuanto menor valor tiene (''min''). Por defecto es valor es ''auto'' y keras sabrá el tipo de la métrica por el nombre que tiene.

<sxh python>

history=model.fit(x_train,y_train,validation_data=(x_test,y_test),epochs=40,verbose=False,callbacks=[EarlyStopping()])
 

</sxh>

Más información:
  * [[https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping| tf.keras.callbacks.EarlyStopping]]
  * [[https://towardsdatascience.com/a-practical-introduction-to-early-stopping-in-machine-learning-550ac88bc8fd|Early Stopping in Practice: an example with Keras and TensorFlow 2.0]]

===== Ejercicios =====

==== Ejercicio 1 ====
Crea una red neuronal para predecir si una persona va a tener una enfermedad cardíaca. Para ello se han usado los datos de {{https://www.kaggle.com/datasets/alexteboul/heart-disease-health-indicators-dataset}}.

Las columnas del dataset son las siguientes:

  * HeartDiseaseorAttack: Indica si el individuo ha experimentado una enfermedad cardíaca o un ataque al corazón. Es lo que hay que predecir.
  * HighBP: Indica si el individuo tiene presión arterial alta.
  * HighChol: Indica si el individuo tiene niveles altos de colesterol.
  * CholCheck: Indica si el individuo ha realizado chequeos de colesterol.
  * BMI: Índice de Masa Corporal del individuo.
  * Smoker: Indica si el individuo fuma.
  * Stroke: Indica si el individuo ha experimentado un derrame cerebral.
  * Diabetes: Indica si el individuo tiene diabetes.
  * PhysActivity: Nivel de actividad física del individuo.
  * Fruits: Consumo de frutas por parte del individuo.
  * Veggies: Consumo de vegetales por parte del individuo.
  * HvyAlcoholConsump: Indica si el individuo consume mucho alcohol 
  * AnyHealthcare: Indica si el individuo tiene acceso a algún tipo de atención médica.
  * NoDocbcCost: Indica si el individuo tiene costos médicos sin documentar.
  * GenHlth: Estado general de salud del individuo.
  * MentHlth: Estado de salud mental del individuo.
  * PhysHlth: Estado de salud física del individuo.
  * DiffWalk: Dificultad para caminar del individuo.
  * Sex: Género del individuo.
  * Age: Edad del individuo.
  * Education: Nivel educativo del individuo.
  * Income: Ingreso económico del individuo.


Los datos son los siguientes: {{ :clase:iabd:pia:2eval:heart_disease_health_indicators_brfss2015.csv.zip |}}
logongas

Herramientas de usuario

Herramientas del sitio

Herramientas de la página
