optimizers_conditionalgradient.ipynb

Kernel: Python 3

Copyright 2020 The TensorFlow Authors.

#@title Licensed under the Apache License, Version 2.0
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Optimizadores de complementos de TensorFlow: ConditionalGradient

Ver en TensorFlow.org

Ejecutar en Google Colab

Ver fuente en GitHub

Descargar bloc de notas

Descripción general

En este bloc de notas se explica cómo usar el optimizador ConditionalGradient del paquete de complementos.

ConditionalGradient

Se ha demostrado que restringir los parámetros de una red neuronal es positivo para el entrenamiento gracias a los efectos de regularización subyacentes. A menudo, los parámetros se restringen mediante una sanción suave (que nunca garantiza el cumplimiento de la restricción) o mediante una operación de proyección (que es costosa desde el punto de vista computacional). En cambio, el optimizador de gradiente condicional (CG) impone las restricciones de forma estricta sin necesidad de recurrir a un costoso paso de proyección. Para ello, minimiza una aproximación lineal del objetivo dentro del conjunto de restricciones. En este bloc de notas, se demuestra la aplicación de la restricción de la norma de Frobenius mediante el optimizador CG en el conjunto de datos MNIST. CG ya está disponible como API de tensorflow. Si desea obtener más información sobre los optimizadores disponibles, consulte https://arxiv.org/pdf/1803.06453.pdf

Preparación

!pip install -U tensorflow-addons

import tensorflow as tf
import tensorflow_addons as tfa
from matplotlib import pyplot as plt

# Hyperparameters
batch_size=64
epochs=10

Generación del modelo

model_1 = tf.keras.Sequential([
    tf.keras.layers.Dense(64, input_shape=(784,), activation='relu', name='dense_1'),
    tf.keras.layers.Dense(64, activation='relu', name='dense_2'),
    tf.keras.layers.Dense(10, activation='softmax', name='predictions'),
])

Preparación de los datos

# Load MNIST dataset as NumPy arrays
dataset = {}
num_validation = 10000
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# Preprocess the data
x_train = x_train.reshape(-1, 784).astype('float32') / 255
x_test = x_test.reshape(-1, 784).astype('float32') / 255

Definición de una función de retrollamada personalizada

def frobenius_norm(m):
    """This function is to calculate the frobenius norm of the matrix of all
    layer's weight.
  
    Args:
        m: is a list of weights param for each layers.
    """
    total_reduce_sum = 0
    for i in range(len(m)):
        total_reduce_sum = total_reduce_sum + tf.math.reduce_sum(m[i]**2)
    norm = total_reduce_sum**0.5
    return norm

CG_frobenius_norm_of_weight = []
CG_get_weight_norm = tf.keras.callbacks.LambdaCallback(
    on_epoch_end=lambda batch, logs: CG_frobenius_norm_of_weight.append(
        frobenius_norm(model_1.trainable_weights).numpy()))

Entrenamiento y evaluación: con CG como optimizador

Sencillamente reemplace los optimizadores típicos de keras por el nuevo optimizador de tfa

# Compile the model
model_1.compile(
    optimizer=tfa.optimizers.ConditionalGradient(
        learning_rate=0.99949, lambda_=203),  # Utilize TFA optimizer
    loss=tf.keras.losses.SparseCategoricalCrossentropy(),
    metrics=['accuracy'])

history_cg = model_1.fit(
    x_train,
    y_train,
    batch_size=batch_size,
    validation_data=(x_test, y_test),
    epochs=epochs,
    callbacks=[CG_get_weight_norm])

Entrenamiento y evaluación: con SDG como optimizador

model_2 = tf.keras.Sequential([
    tf.keras.layers.Dense(64, input_shape=(784,), activation='relu', name='dense_1'),
    tf.keras.layers.Dense(64, activation='relu', name='dense_2'),
    tf.keras.layers.Dense(10, activation='softmax', name='predictions'),
])

SGD_frobenius_norm_of_weight = []
SGD_get_weight_norm = tf.keras.callbacks.LambdaCallback(
    on_epoch_end=lambda batch, logs: SGD_frobenius_norm_of_weight.append(
        frobenius_norm(model_2.trainable_weights).numpy()))

# Compile the model
model_2.compile(
    optimizer=tf.keras.optimizers.SGD(0.01),  # Utilize SGD optimizer
    loss=tf.keras.losses.SparseCategoricalCrossentropy(),
    metrics=['accuracy'])

history_sgd = model_2.fit(
    x_train,
    y_train,
    batch_size=batch_size,
    validation_data=(x_test, y_test),
    epochs=epochs,
    callbacks=[SGD_get_weight_norm])

Norma de Frobenius de los pesos: comparación entre CG y SGD

La implementación actual del optimizador CG está basada en la Norma de Frobenius, y considera la Norma de Frobenius como regularizador en la función objetivo. Por lo tanto, se compara el efecto regularizado de CG con el optimizador SGD, que no ha impuesto el regularizador de la Norma de Frobenius.

plt.plot(
    CG_frobenius_norm_of_weight,
    color='r',
    label='CG_frobenius_norm_of_weights')
plt.plot(
    SGD_frobenius_norm_of_weight,
    color='b',
    label='SGD_frobenius_norm_of_weights')
plt.xlabel('Epoch')
plt.ylabel('Frobenius norm of weights')
plt.legend(loc=1)

Precisión del entrenamiento y la validación: comparación entre CG y SGD

plt.plot(history_cg.history['accuracy'], color='r', label='CG_train')
plt.plot(history_cg.history['val_accuracy'], color='g', label='CG_test')
plt.plot(history_sgd.history['accuracy'], color='pink', label='SGD_train')
plt.plot(history_sgd.history['val_accuracy'], color='b', label='SGD_test')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend(loc=4)