Devolución de llamada personalizada de Keras | Pitón |

importar queras

de queras.modelos importar Secuencial

de queras.capas importar Denso, Abandonar, Aplanar

de queras.capas importar Conv2D, MaxPooling2D

de queras importar back-end como k

de queras.conjuntos de datos importar moda_mnista

de queras.devoluciones de llamada importar LambdaCallback

tamaño del lote = 128

num_clases = 10

épocas = 12

# dimensiones de la imagen de entrada

img_filas, img_cols = 28, 28

# los datos, divididos entre conjuntos de entrenamiento y prueba

(x_tren, y_tren), (x_prueba, y_prueba) = moda_mnista.Cargar datos()

si k.formato_de_datos_de_imagen() == ‘canales_primero’:

x_tren = x_tren.remodelar(x_tren.forma[0], 1, img_filas, img_cols)

x_prueba = x_prueba.remodelar(x_prueba.forma[0], 1, img_filas, img_cols)

entrada_forma = (1, img_filas, img_cols)

demás:

x_tren = x_tren.remodelar(x_tren.forma[0], img_filas, img_cols, 1)

x_prueba = x_prueba.remodelar(x_prueba.forma[0], img_filas, img_cols, 1)

entrada_forma = (img_filas, img_cols, 1)

x_tren = x_tren.un tipo(‘flotador32’)

x_prueba = x_prueba.un tipo(‘flotador32’)

x_tren /= 255

x_prueba /= 255

imprimir(‘x_tren forma:’, x_tren.forma)

imprimir(x_tren.forma[0], ‘muestras de tren’)

imprimir(x_prueba.forma[0], ‘muestras de prueba’)

# convertir vectores de clase a matrices de clase binaria

y_tren = queras.útiles.a_categórico(y_tren, num_clases)

y_prueba = queras.útiles.a_categórico(y_prueba, num_clases)

#Construyendo nuestra CNN

modelo = Secuencial()

modelo.agregar(Conv2D(32, kernel_size=(3, 3),

activación=‘relú’,

entrada_forma=entrada_forma))

modelo.agregar(Conv2D(64, (3, 3), activación=‘relú’))

modelo.agregar(MaxPooling2D(tamaño de la piscina=(2, 2)))

modelo.agregar(Abandonar(0.25))

modelo.agregar(Aplanar())

modelo.agregar(Denso(128, activación=‘relú’))

modelo.agregar(Abandonar(0.5))

modelo.agregar(Denso(num_clases, activación=‘softmax’))

#compilar el modelo

modelo.compilar(pérdida=queras.pérdidas.categorical_crossentropy,

optimizador=queras.optimizadores.Adadelta(),

métrica=[‘accuracy’])

#creando una función que será llamada al final de la época

definitivamente al_final_de_la_época(_,registros):

LÍMITE = 0.90

si(registros[‘val_acc’]> LÍMITE):

modelo.detener_entrenar=Verdadero

imprimir(‘Deteniendo el entrenamiento. La precisión de la validación alcanza el 90 %’)

lambdac = LambdaCallback(al_final_de_la_época=al_final_de_la_época)

historia = modelo.adaptar(x_tren, y_tren,

tamaño del lote=tamaño del lote,

épocas=épocas,

verboso=1,

validación_dividir=0.3,

devoluciones de llamada=[lambdac])