python - tutorial - Carga el punto de control guardado y predice que no se producirán los mismos resultados que en el entrenamiento

tensorflow python español

Question

Estoy entrenando basado en un código de ejemplo que encontré en Internet. La precisión en las pruebas es del 92% y los puntos de control se guardan en un directorio. En paralelo (la capacitación dura 3 días) quiero crear mi código de predicción para poder aprender más en lugar de simplemente esperar.

Este es mi tercer día de aprendizaje profundo, así que probablemente no sé lo que estoy haciendo. Así es como estoy tratando de predecir:

• Crea una instancia del modelo usando el mismo código que en el entrenamiento
• Cargar el último punto de control.
• Tratar de predecir

El código funciona pero los resultados no se acercan al 90%.

Así es como creo el modelo:

INPUT_LAYERS = 2
OUTPUT_LAYERS = 2
AMOUNT_OF_DROPOUT = 0.3
HIDDEN_SIZE = 700
INITIALIZATION = "he_normal"  # : Gaussian initialization scaled by fan_in (He et al., 2014)
CHARS = list("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ .")

def generate_model(output_len, chars=None):
    """Generate the model"""
    print(''Build model...'')
    chars = chars or CHARS
    model = Sequential()
    # "Encode" the input sequence using an RNN, producing an output of HIDDEN_SIZE
    # note: in a situation where your input sequences have a variable length,
    # use input_shape=(None, nb_feature).
    for layer_number in range(INPUT_LAYERS):
        model.add(recurrent.LSTM(HIDDEN_SIZE, input_shape=(None, len(chars)), init=INITIALIZATION,
                         return_sequences=layer_number + 1 < INPUT_LAYERS))
        model.add(Dropout(AMOUNT_OF_DROPOUT))
    # For the decoder''s input, we repeat the encoded input for each time step
    model.add(RepeatVector(output_len))
    # The decoder RNN could be multiple layers stacked or a single layer
    for _ in range(OUTPUT_LAYERS):
        model.add(recurrent.LSTM(HIDDEN_SIZE, return_sequences=True, init=INITIALIZATION))
        model.add(Dropout(AMOUNT_OF_DROPOUT))

    # For each of step of the output sequence, decide which character should be chosen
    model.add(TimeDistributed(Dense(len(chars), init=INITIALIZATION)))
    model.add(Activation(''softmax''))

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

En un archivo separado predict.py , importo este método para crear mi modelo e intento predecir:

...import code
model = generate_model(len(question), dataset[''chars''])
model.load_weights(''models/weights.204-0.20.hdf5'')

def decode(pred):
    return character_table.decode(pred, calc_argmax=False)


x = np.zeros((1, len(question), len(dataset[''chars''])))
for t, char in enumerate(question):
    x[0, t, character_table.char_indices[char]] = 1.

preds = model.predict_classes([x], verbose=0)[0]

print("======================================")
print(decode(preds))

No sé cuál es el problema. Tengo cerca de 90 puntos de control en mi directorio y estoy cargando el último en base a la precisión. Todos ellos guardados por un ModelCheckpoint :

checkpoint = ModelCheckpoint(MODEL_CHECKPOINT_DIRECTORYNAME + ''/'' + MODEL_CHECKPOINT_FILENAME,
                         save_best_only=True)

Estoy atascado. ¿Qué estoy haciendo mal?

Answer 1

Cuando genera un modelo en su archivo predict.py:

model = generate_model(len(question), dataset[''chars''])

¿Es tu primer parámetro el mismo que en tu archivo de entrenamiento? ¿O es dinámica la longitud de la pregunta? Si es así, está generando un modelo diferente, por lo tanto, su punto de control guardado no funciona.

Answer 2

En el repositorio que proporcionó, las oraciones de entrenamiento y validación se invierten antes de incorporarse al modelo (como se hace comúnmente en el aprendizaje de seq2seq).

dataset = DataSet(DATASET_FILENAME)

Como puede ver, el valor predeterminado para inverted es True , y las preguntas están invertidas.

class DataSet(object):
    def __init__(self, dataset_filename, test_set_fraction=0.1, inverted=True):
        self.inverted = inverted

    ...

        question = question[::-1] if self.inverted else question
        questions.append(question)

Puedes intentar invertir las oraciones durante la predicción. Específicamente,

x = np.zeros((1, len(question), len(dataset[''chars''])))
for t, char in enumerate(question):
    x[0, len(question) - t - 1, character_table.char_indices[char]] = 1.

Answer 3

Puede ser la dimensionalidad de las matrices / df pasadas que no coinciden con lo que esperan las funciones a las que llama. Cuando el método llamado espera una única dimensión, pruebe con lo que espera que sea una única dimensión.