No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Entrenamiento del modelo de clasificación múltiple

24/28
Recursos

Aportes 17

Preguntas 1

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Esta es mi arquitectura y la gráfica:

model = models.Sequential()
model.add(layers.Dense(65, activation='relu', input_shape=(10000,)))
model.add(layers.Dropout(0.75))
model.add(layers.Dense(65, activation='relu'))
model.add(layers.Dropout(0.25))
model.add(layers.Dense(46, activation='softmax'))

model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['acc']   
             )

x_val2 = x_train[:1000]
partial_x_train2 = x_train[1000:]

y_val2 = y_train[:1000]
partial_y_train2 =  y_train[1000:]

history2 = model.fit(partial_x_train2,
                   partial_y_train2,
                   epochs=25,
                   batch_size=512,
                   validation_data=(x_val2,y_val2))

loss: 1.1468 - acc: 0.7689

Sin utilizar regularizaciones, simplemente jugando con los sets de validación, en lugar de separar los sets al inicio los separo en el entrenamiento con validation_spli y ahi voy jugando con diferentes valores así:

historia1=model1.fit(x_train,y_train,epochs=9,batch_size=512,validation_split=0.3,verbose=0);

con esos datos me sale :

Lo mejor que logré fue un “Accuracy” de .7947 (el modelo original logra .7867)

Red con 3 capas: 80
Regularizador L2 0.001
Dropout en ambas capas de 0.05
Epochs: 9

, 80 y 46

3 capas dropout de .5 y .25 entre capas y regularizador l2 0.001. Con 50 epocas

Cumpliendo el reto

Resultados

  • Se logra solucionar el problema de overfiting. Los valores del val_loss se bajan en promedio a 0.03 y el val_accuracy obtenido es de 0.82.
  • Se probado en aumentar la cantidad de capas para mejorar el accuracy, pero el efecto es inverso. Es más, se tienen los mismos resultados del punto anterior con solo una caps
    .

Regularización L2

# 1 definición del modelo
regularizedL2_model = models.Sequential()
regularizedL2_model.add(layers.Dense(64, activation='relu', input_shape=(10000,),
                                   kernel_regularizer=regularizers.l2(0.00002)))
regularizedL2_model.add(layers.Dense(64, activation='relu',
                                   kernel_regularizer=regularizers.l2(0.00002)))
regularizedL2_model.add(layers.Dense(46, activation='softmax'))


# 2 Compilación del modelo
regularizedL2_model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['acc'])

# 3 Entrenamiento del modelo
history_regularizedL2_model = regularizedL2_model.fit(partial_x_train,
                                                  partial_y_train,
                                                  epochs=20,
                                                  batch_size=512,
                                                  validation_data=(x_val, y_val))
# 4 Validación
epoch = range(1,len(history_basic_model.history['val_loss'])+1)

plt.plot(epoch,history_regularizedL2_model.history['val_loss'], 'o',label='training')
plt.plot(epoch,history_regularizedL2_model.history['loss'], '--',label='validation')
plt.legend()
plt.title('Loss values - regularized L2 model')
plt.show()
print('='*100)

plt.plot(epoch,history_regularizedL2_model.history['val_loss'], 'o',label='Regularized Model')
plt.plot(epoch,history_basic_model.history['val_loss'], '--',label='Basic Model')
plt.legend()
plt.title('Loss values')
plt.show()
print('='*100)

plt.plot(epoch,history_regularizedL2_model.history['val_acc'], 'o',label='Regularized Model')
plt.plot(epoch,history_basic_model.history['val_acc'], '--',label='Basic Model')
plt.legend()
plt.title('Accuracy values')
plt.show() 

.

Regularización L1

# 1 definición del modelo
regularizedL1_model = models.Sequential()
regularizedL1_model.add(layers.Dense(64, activation='relu', input_shape=(10000,),
                                   kernel_regularizer=regularizers.l1(0.000002)))
regularizedL1_model.add(layers.Dense(64, activation='relu',
                                   kernel_regularizer=regularizers.l1(0.000002)))
regularizedL1_model.add(layers.Dense(46, activation='softmax'))


# 2 Compilación del modelo
regularizedL1_model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['acc'])

# 3 Entrenamiento del modelo
history_regularizedL1_model = regularizedL1_model.fit(partial_x_train,
                                                  partial_y_train,
                                                  epochs=20,
                                                  batch_size=512,
                                                  validation_data=(x_val, y_val))
# 4 Validación
epoch = range(1,len(history_basic_model.history['val_loss'])+1)

plt.plot(epoch,history_regularizedL1_model.history['val_loss'], 'o',label='training')
plt.plot(epoch,history_regularizedL1_model.history['loss'], '--',label='validation')
plt.legend()
plt.title('Loss values - regularized L1 model')
plt.show()
print('='*100)

plt.plot(epoch,history_regularizedL1_model.history['val_loss'], '+',label='Regularized L1 Model')
plt.plot(epoch,history_regularizedL2_model.history['val_loss'], 'o',label='Regularized L2 Model')
plt.plot(epoch,history_basic_model.history['val_loss'], '--',label='Basic Model')
plt.legend()
plt.title('Loss values')
plt.show()
print('='*100)

plt.plot(epoch,history_regularizedL1_model.history['val_acc'], '+',label='Regularized L1 Model')
plt.plot(epoch,history_regularizedL2_model.history['val_acc'], 'o',label='Regularized L2 Model')
plt.plot(epoch,history_basic_model.history['val_acc'], '--',label='Basic Model')
plt.legend()
plt.title('Accuracy values')
plt.show()

.

Regularización con Dropout

# 1 definición del modelo
reg_dropout_model = models.Sequential()
reg_dropout_model.add(layers.Dense(64, activation='relu', input_shape=(10000,)))
reg_dropout_model.add(layers.Dropout(0.2))

reg_dropout_model.add(layers.Dense(64, activation='relu'))
reg_dropout_model.add(layers.Dropout(0.2))

reg_dropout_model.add(layers.Dense(64, activation='relu'))
reg_dropout_model.add(layers.Dropout(0.2))

reg_dropout_model.add(layers.Dense(46, activation='softmax'))


# 2 Compilación del modelo
reg_dropout_model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['acc'])

# 3 Entrenamiento del modelo
history_reg_dropout_model = reg_dropout_model.fit(partial_x_train,
                                                  partial_y_train,
                                                  epochs=20,
                                                  batch_size=512,
                                                  validation_data=(x_val, y_val))
# 4 Validación
epoch = range(1,len(history_basic_model.history['val_loss'])+1)

plt.plot(epoch,history_reg_dropout_model.history['val_loss'], 'o',label='training')
plt.plot(epoch,history_reg_dropout_model.history['loss'], '--',label='validation')
plt.legend()
plt.title('Loss values - Dropout Model')
plt.show()
print('='*100)

plt.plot(epoch,history_reg_dropout_model.history['val_loss'], '*',label='Dropout Model')
plt.plot(epoch,history_regularizedL1_model.history['val_loss'], '+',label='Regularized L1 Model')
plt.plot(epoch,history_regularizedL2_model.history['val_loss'], 'o',label='Regularized L2 Model')
plt.plot(epoch,history_basic_model.history['val_loss'], '--',label='Basic Model')
plt.legend()
plt.title('Loss values')
plt.show()
print('='*100)

plt.plot(epoch,history_reg_dropout_model.history['val_acc'], '*',label='Dropout Model')
plt.plot(epoch,history_regularizedL1_model.history['val_acc'], '+',label='Regularized L1 Model')
plt.plot(epoch,history_regularizedL2_model.history['val_acc'], 'o',label='Regularized L2 Model')
plt.plot(epoch,history_basic_model.history['val_acc'], '--',label='Basic Model')
plt.legend()
plt.title('Accuracy values')
plt.show()

Regularización con L1-L2

# 1 definición del modelo
reg_L1L2_model = models.Sequential()
reg_L1L2_model.add(layers.Dense(64, activation='relu', input_shape=(10000,),
                                   kernel_regularizer=regularizers.l1_l2(l1=0.000001, l2=0.00001)))

# reg_L1L2_model.add(layers.Dense(64, activation='relu',
#                                    kernel_regularizer=regularizers.l1_l2(l1=0.000001, l2=0.00001)))

# reg_L1L2_model.add(layers.Dense(64, activation='relu',
#                                    kernel_regularizer=regularizers.l1_l2(l1=0.000001, l2=0.00001)))

reg_L1L2_model.add(layers.Dense(46, activation='softmax'))


# 2 Compilación del modelo
reg_L1L2_model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['acc'])

# 3 Entrenamiento del modelo
history_reg_L1L2_model = reg_L1L2_model.fit(partial_x_train,
                                                  partial_y_train,
                                                  epochs=20,
                                                  batch_size=512,
                                                  validation_data=(x_val, y_val))

Outcome 0.7959

Loss

Model

Mi reto resuelto:

Mi modelo arrojo los siguientes resultados:

loss: 0.0214 - acc: 0.8896

Utilize primero reduccion del numero de neuronas a 3 capas de 46 neuronas lo que me dio un accuracy: 0.95 y loss 0.0946, sobre ese avance hice regularization sin muchos resultados y luego con dropout a 0.25 tarde 27 epoch en alcanzar el overfitting. aqui les comparto el codigo:

model4 = models.Sequential()
model3.add(layers.Dense(46, activation='relu', input_shape=(10000,),kernel_regularizer=regularizers.l2(0.0000001)))
model4.add(layers.Dropout(0.25))
model3.add(layers.Dense(46, activation='relu',kernel_regularizer=regularizers.l2(0.0000001)))
model4.add(layers.Dropout(0.25))
model4.add(layers.Dense(46, activation='softmax'))

model4.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
             metrics=['acc'])

history4 = model4.fit(partial_x_train,
                   partial_y_train,
                   epochs=29,
                   batch_size=512,
                   validation_data=(x_val,y_val))


model = models.Sequential()
model.add(layers.Dense(80, activation='relu', input_shape=(10000,), kernel_regularizer=regularizers.l2(0.0005)))
model.add(layers.Dropout(0.45))
model.add(layers.Dense(80, activation='relu'))
model.add(layers.Dense(46, activation='softmax'))

model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['acc']   
             )
history = model.fit(partial_x_train,
                   partial_y_train,
                   epochs=10,
                   batch_size=512,
                   validation_data=(x_val,y_val))

De esta manera consegui un accuracy de 0.8045

0.80 Accuracy y 1.11 loss:
Misma arquitectura pero combinando Dropout y regularizers:

from tensorflow.keras import regularizers
model = models.Sequential()
model.add(layers.Dense(65, activation='relu', input_shape=(10000,), kernel_regularizer=regularizers.l2(0.01)))
model.add(layers.Dropout(0.75))
model.add(layers.Dense(65, activation='relu', kernel_regularizer=regularizers.l2(0.01)))
model.add(layers.Dropout(0.25))
model.add(layers.Dense(46, activation='softmax'))
history = model.fit(partial_x_train,
                   partial_y_train,
                   epochs=25,
                   batch_size=512,
                   validation_data=(x_val,y_val))

Estos son los resultados de los cambios en mi red mejoro bastante pero aún le falta.

model = models.Sequential()

model.add(
    layers.Dense(
        64,
        activation='relu',
        input_shape=(10000,),
        kernel_regularizer=regularizers.l2(0.01)
    )
)

model.add(layers.Dropout(0.6))

model.add(
    layers.Dense(
        64,
        activation='relu',
        kernel_regularizer=regularizers.l2(0.01)
    )
)

model.add(layers.Dropout(0.5))


"""
No usamos sigmoid porque la relacion binaria de 0 a 1 no me permitiria
realizar clasificacion multiple

en su lugar la funcion sigmoid, con una relacion de -1 a 1 nos permite
clasificar cada una de las posibles salidas sin importar la cantidad
en base a la relacion de ser y no ser una categoria
"""
model.add(
    layers.Dense(
        46,
        activation='softmax'
    )
)

model.compile(
    optimizer='rmsprop',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# entrenar el modelo
history = model.fit(partial_x_train, partial_y_train,
    epochs=14,
    batch_size=256,
    validation_data=(x_val, y_val)
)

En la función “clean” tenemos los modelos, podemos modificar los parámetros y ejecutar para evaluar cual es la mejor opción.

from keras import layers, models, optimizers, regularizers
import numpy as np
from  keras.datasets import reuters
from clasific_binaria import vectorizar
from tensorflow.keras.utils import to_categorical
import matplotlib.pyplot as plt


def train(x_train, x_test, y_train, y_test, neuronas, epchs, name, regularation, dropout):
    # SOFTMAX / IDEAL PARA CLASIFICACION MULTIPLE / DA LA PROBABILIDAD DE CADA SALIDA SIN IMPORTAR CUANTAS TENGA
    model = models.Sequential()
    if regularation:
            model.add(layers.Dense(neuronas, activation='relu', input_shape=(10000,), kernel_regularizer= regularizers.l2(0.001)))
    else:
        model.add(layers.Dense(neuronas, activation='relu', input_shape=(10000,)))
    
    if dropout:
        model.add(layers.Dropout(0.5))
    model.add(layers.Dense(neuronas, activation='relu'))

    if dropout:
        model.add(layers.Dropout(0.5))
    model.add(layers.Dense(46, activation='softmax'))

    # categorical_crossentropy / clasificacion multiple ideal
    model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['acc'])

    x_val = x_train[:1000]
    partial_x_train = x_train[1000:]
    y_val = y_train[:1000]
    partial_y_train= y_train[1000:]

    historia = model.fit(partial_x_train, partial_y_train, epochs=epchs, batch_size=512, validation_data=(x_val, y_val))

    historia_dict = historia.history
    loss_values = historia_dict['loss']
    val_loss_values = historia_dict['val_loss']
    fig = plt.figure(figsize=(10,10))
  
    epoch = range(1, len(loss_values)+1)
    plt.plot(epoch, loss_values, 'o', label = 'training')
    plt.plot(epoch, val_loss_values, '--', label = 'validation')
    plt.legend()
    plt.show()

    # Me genera una matriz con las salidas / escogemos el que tiene mas porcentaje de 
    # ser correcta con np.argmax
    predictions = model.predict(x_test)
    print(np.argmax(predictions[0]))
    # print(predictions)

    return   (name, model.evaluate(x_test,y_test))
    

def clean(train_data, test_data, train_labels, test_labels):
    word_index = reuters.get_word_index()
    word_index = dict([(value,key) for (key,value) in word_index.items()])

    for _ in train_data[0]:
        print(word_index.get(_ - 3))
    
    # VECTORIZAR / TRANSFORMA A TENSOR
    # TO_CATEGORICAL / IDEAL PARA PROBLEMAS DE CLASIFICACION
    x_train, x_test = vectorizar(train_data, dim=10000), vectorizar(test_data, dim=10000)
    y_train, y_test = to_categorical(train_labels), to_categorical(test_labels)

    first_model = train(x_train, x_test, y_train, y_test, neuronas=64, epchs=30, name='first_model', regularation=False, dropout=False)
    print(first_model)

    second_model = train(x_train, x_test, y_train, y_test, neuronas=64, epchs=9, name='second_model', regularation=False, dropout=False)
    print(second_model)

    thrid_model =  train(x_train, x_test, y_train, y_test, neuronas=64, epchs=9, name='third_model', regularation=True, dropout=False)
    print(thrid_model)

    fourth_model = train(x_train, x_test, y_train, y_test, neuronas=64, epchs=9, name='fourth_model', regularation=True, dropout=True)
    print(fourth_model)

def load():
    (train_data, train_labels), (test_data, test_labels) = reuters.load_data(num_words=10000)
    clean(train_data, test_data, train_labels, test_labels)

def main():
    load()


if __name__ == '__main__':
    main()

Con 30 epochs, 128 layers, L2=0.001 y Dropout=0.3

from keras import regularizers

Estructura red neuronal

model2 = models.Sequential()

model2.add(layers.Dense(65, activation=‘relu’, input_shape=(10000,)))

model2.add(layers.Dropout(0.75))

model2.add(layers.Dense(65, activation=‘relu’, kernel_regularizer= regularizers.l2(0.001)))

model2.add(layers.Dense(46, activation=‘softmax’)) # se lleva muy bien con la clasificacion multiple.

compilador

model2.compile(optimizer = ‘rmsprop’,
loss=‘categorical_crossentropy’, # especial para clasificacionultiple
metrics=[‘acc’] )

x_val2 = x_train[:1000]
partial_x_train2 = x_train[1000:]

y_val2 = y_train[:1000]
partial_y_train2 = y_train[1000:]

history2 = model2.fit(partial_x_train2,
partial_y_train2,
epochs = 20,
batch_size=512, # lotes de datos
validation_data = (x_val2,y_val2)
)

loss: 1.1321 - acc: 0.7707

Estas son las graficas de mi modelo:

Loss:

Accuracy:

Y acá el código del modelo:

model = models.Sequential()
model.add(layers.Dense(62, activation='relu', input_shape=(10000,), kernel_regularizer=regularizers.l2(0.01)))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(50, activation='relu', kernel_regularizer=regularizers.l2(0.01)))
model.add(layers.Dropout(0.25))
model.add(layers.Dense(46, activation='softmax'))

model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
<h3>Mi modelo más alto fue:</h3>
# Create model with 3 layers of 48 neurons, with regularizers and dropaout layers
model2= models.Sequential()
model2.add(layers.Dense(48, activation='relu', input_shape = (10000,))) 
model2.add(layers.Dropout(0.5))
model2.add(layers.Dense(48, activation='relu', kernel_regularizer=regularizers.l2(0.001))) 
model2.add(layers.Dense(46, activation='softmax')) 

La primera capa tiene regularización l2 a 0.001 sin dropout y la segunda capa no tiene regularización y tiene dropout a 50%

# train model with 16 epoch
history2 = model2.fit(partial_x_train, partial_y_train,
            epochs=16,
            batch_size=512,
            validation_data=(x_val, y_val))

Modelo con 16 epocas

loss: 1.0544 - accuracy: 0.7827