Esta página foi traduzida pela API Cloud Translation.
Switch to English

Cluster de peso no exemplo Keras

Ver em TensorFlow.org Executar no Google Colab Ver fonte no GitHub Download do caderno

Visão geral

Bem-vindo ao exemplo de ponta a ponta para agrupamento de pesos , parte do TensorFlow Model Optimization Toolkit.

Outras páginas

Para obter uma introdução ao que é agrupamento por peso e para determinar se você deve usá-lo (incluindo o que é suportado), consulte a página de visão geral .

Para encontrar rapidamente as APIs necessárias para seu caso de uso (além de agrupar completamente um modelo com 16 clusters), consulte o guia abrangente .

Conteúdo

No tutorial, você irá:

  1. Treine um modelo tf.keras para o conjunto de dados MNIST do zero.
  2. Ajuste o modelo aplicando a API de agrupamento de pesos e veja a precisão.
  3. Crie modelos TF e TFLite 6x menores a partir do cluster.
  4. Crie um modelo TFLite 8x menor, combinando agrupamento de pesos e quantização pós-treinamento.
  5. Veja a persistência da precisão de TF para TFLite.

Configuração

Você pode executar este Notebook Jupyter em seu virtualenv ou colab local. Para detalhes sobre a configuração de dependências, consulte o guia de instalação .

 pip install -q tensorflow-model-optimization
 import tensorflow as tf
from tensorflow import keras

import numpy as np
import tempfile
import zipfile
import os
 

Treinar um modelo tf.keras para MNIST sem cluster

 # Load MNIST dataset
mnist = keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# Normalize the input image so that each pixel value is between 0 to 1.
train_images = train_images / 255.0
test_images  = test_images / 255.0

# Define the model architecture.
model = keras.Sequential([
    keras.layers.InputLayer(input_shape=(28, 28)),
    keras.layers.Reshape(target_shape=(28, 28, 1)),
    keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation=tf.nn.relu),
    keras.layers.MaxPooling2D(pool_size=(2, 2)),
    keras.layers.Flatten(),
    keras.layers.Dense(10)
])

# Train the digit classification model
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

model.fit(
    train_images,
    train_labels,
    validation_split=0.1,
    epochs=10
)
 
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
Epoch 1/10
1688/1688 [==============================] - 7s 4ms/step - loss: 0.3352 - accuracy: 0.9039 - val_loss: 0.1543 - val_accuracy: 0.9575
Epoch 2/10
1688/1688 [==============================] - 7s 4ms/step - loss: 0.1535 - accuracy: 0.9559 - val_loss: 0.0948 - val_accuracy: 0.9745
Epoch 3/10
1688/1688 [==============================] - 7s 4ms/step - loss: 0.1003 - accuracy: 0.9715 - val_loss: 0.0750 - val_accuracy: 0.9788
Epoch 4/10
1688/1688 [==============================] - 7s 4ms/step - loss: 0.0791 - accuracy: 0.9768 - val_loss: 0.0652 - val_accuracy: 0.9828
Epoch 5/10
1688/1688 [==============================] - 7s 4ms/step - loss: 0.0669 - accuracy: 0.9803 - val_loss: 0.0663 - val_accuracy: 0.9807
Epoch 6/10
1688/1688 [==============================] - 7s 4ms/step - loss: 0.0589 - accuracy: 0.9820 - val_loss: 0.0581 - val_accuracy: 0.9833
Epoch 7/10
1688/1688 [==============================] - 7s 4ms/step - loss: 0.0528 - accuracy: 0.9840 - val_loss: 0.0584 - val_accuracy: 0.9832
Epoch 8/10
1688/1688 [==============================] - 8s 5ms/step - loss: 0.0479 - accuracy: 0.9854 - val_loss: 0.0560 - val_accuracy: 0.9838
Epoch 9/10
1688/1688 [==============================] - 7s 4ms/step - loss: 0.0434 - accuracy: 0.9867 - val_loss: 0.0550 - val_accuracy: 0.9853
Epoch 10/10
1688/1688 [==============================] - 7s 4ms/step - loss: 0.0393 - accuracy: 0.9880 - val_loss: 0.0571 - val_accuracy: 0.9845

<tensorflow.python.keras.callbacks.History at 0x7fd1a1e18668>

Avalie o modelo de linha de base e salve-o para uso posterior

 _, baseline_model_accuracy = model.evaluate(
    test_images, test_labels, verbose=0)

print('Baseline test accuracy:', baseline_model_accuracy)

_, keras_file = tempfile.mkstemp('.h5')
print('Saving model to: ', keras_file)
tf.keras.models.save_model(model, keras_file, include_optimizer=False)
 
Baseline test accuracy: 0.9805999994277954
Saving model to:  /tmp/tmpphs68ctq.h5

Ajuste o modelo pré-treinado com armazenamento em cluster

Aplique a API cluster_weights() a todo um modelo pré-treinado para demonstrar sua eficácia na redução do tamanho do modelo após aplicar zip, mantendo uma precisão decente. Para saber a melhor forma de equilibrar a precisão e a taxa de compactação do seu caso de uso, consulte o exemplo por camada no guia completo .

Defina o modelo e aplique a API de armazenamento em cluster

Antes de passar o modelo para a API de cluster, verifique se ele foi treinado e mostra alguma precisão aceitável.

 import tensorflow_model_optimization as tfmot

cluster_weights = tfmot.clustering.keras.cluster_weights
CentroidInitialization = tfmot.clustering.keras.CentroidInitialization

clustering_params = {
  'number_of_clusters': 16,
  'cluster_centroids_init': CentroidInitialization.LINEAR
}

# Cluster a whole model
clustered_model = cluster_weights(model, **clustering_params)

# Use smaller learning rate for fine-tuning clustered model
opt = tf.keras.optimizers.Adam(learning_rate=1e-5)

clustered_model.compile(
  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
  optimizer=opt,
  metrics=['accuracy'])

clustered_model.summary()
 
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
cluster_reshape (ClusterWeig (None, 28, 28, 1)         0         
_________________________________________________________________
cluster_conv2d (ClusterWeigh (None, 26, 26, 12)        136       
_________________________________________________________________
cluster_max_pooling2d (Clust (None, 13, 13, 12)        0         
_________________________________________________________________
cluster_flatten (ClusterWeig (None, 2028)              0         
_________________________________________________________________
cluster_dense (ClusterWeight (None, 10)                20306     
=================================================================
Total params: 20,442
Trainable params: 54
Non-trainable params: 20,388
_________________________________________________________________

Ajuste o modelo e avalie a precisão em relação à linha de base

Ajuste o modelo com armazenamento em cluster por 1 época.

 # Fine-tune model
clustered_model.fit(
  train_images,
  train_labels,
  batch_size=500,
  epochs=1,
  validation_split=0.1)
 
108/108 [==============================] - 2s 16ms/step - loss: 0.0535 - accuracy: 0.9821 - val_loss: 0.0692 - val_accuracy: 0.9803

<tensorflow.python.keras.callbacks.History at 0x7fd18437ee10>

Neste exemplo, há uma perda mínima na precisão do teste após o clustering, em comparação com a linha de base.

 _, clustered_model_accuracy = clustered_model.evaluate(
  test_images, test_labels, verbose=0)

print('Baseline test accuracy:', baseline_model_accuracy)
print('Clustered test accuracy:', clustered_model_accuracy)
 
Baseline test accuracy: 0.9805999994277954
Clustered test accuracy: 0.9753000140190125

Crie modelos 6x menores do cluster

O strip_clustering e a aplicação de um algoritmo de compactação padrão (por exemplo, via gzip) são necessários para ver os benefícios de compactação do clustering.

Primeiro, crie um modelo compressível para o TensorFlow. Aqui, strip_clustering remove todas as variáveis ​​(por exemplo, tf.Variable para armazenar os centróides e índices do cluster) de que o cluster precisa apenas durante o treinamento, o que de outra forma aumentaria o tamanho do modelo durante a inferência.

 final_model = tfmot.clustering.keras.strip_clustering(clustered_model)

_, clustered_keras_file = tempfile.mkstemp('.h5')
print('Saving clustered model to: ', clustered_keras_file)
tf.keras.models.save_model(final_model, clustered_keras_file, 
                           include_optimizer=False)
 
Saving clustered model to:  /tmp/tmpfnmtfvf8.h5

Em seguida, crie modelos compressíveis para o TFLite. Você pode converter o modelo em cluster para um formato que possa ser executado no seu back-end direcionado. O TensorFlow Lite é um exemplo que você pode usar para implantar em dispositivos móveis.

 clustered_tflite_file = '/tmp/clustered_mnist.tflite'
converter = tf.lite.TFLiteConverter.from_keras_model(final_model)
tflite_clustered_model = converter.convert()
with open(clustered_tflite_file, 'wb') as f:
  f.write(tflite_clustered_model)
print('Saved clustered TFLite model to:', clustered_tflite_file)
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /tmp/tmpe966h_56/assets
Saved clustered TFLite model to: /tmp/clustered_mnist.tflite

Defina uma função auxiliar para realmente comprimir os modelos via gzip e medir o tamanho compactado.

 def get_gzipped_model_size(file):
  # It returns the size of the gzipped model in bytes.
  import os
  import zipfile

  _, zipped_file = tempfile.mkstemp('.zip')
  with zipfile.ZipFile(zipped_file, 'w', compression=zipfile.ZIP_DEFLATED) as f:
    f.write(file)

  return os.path.getsize(zipped_file)
 

Compare e veja que os modelos são 6x menores do que o cluster

 print("Size of gzipped baseline Keras model: %.2f bytes" % (get_gzipped_model_size(keras_file)))
print("Size of gzipped clustered Keras model: %.2f bytes" % (get_gzipped_model_size(clustered_keras_file)))
print("Size of gzipped clustered TFlite model: %.2f bytes" % (get_gzipped_model_size(clustered_tflite_file)))
 
Size of gzipped baseline Keras model: 78076.00 bytes
Size of gzipped clustered Keras model: 13362.00 bytes
Size of gzipped clustered TFlite model: 12982.00 bytes

Crie um modelo TFLite 8x menor, combinando agrupamento de pesos e quantização pós-treinamento

Você pode aplicar a quantização pós-treinamento ao modelo em cluster para obter benefícios adicionais.

 converter = tf.lite.TFLiteConverter.from_keras_model(final_model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant_model = converter.convert()

_, quantized_and_clustered_tflite_file = tempfile.mkstemp('.tflite')

with open(quantized_and_clustered_tflite_file, 'wb') as f:
  f.write(tflite_quant_model)

print('Saved quantized and clustered TFLite model to:', quantized_and_clustered_tflite_file)
print("Size of gzipped baseline Keras model: %.2f bytes" % (get_gzipped_model_size(keras_file)))
print("Size of gzipped clustered and quantized TFlite model: %.2f bytes" % (get_gzipped_model_size(quantized_and_clustered_tflite_file)))
 
INFO:tensorflow:Assets written to: /tmp/tmpg0gw8r5x/assets

INFO:tensorflow:Assets written to: /tmp/tmpg0gw8r5x/assets

Saved quantized and clustered TFLite model to: /tmp/tmp43crqft1.tflite
Size of gzipped baseline Keras model: 78076.00 bytes
Size of gzipped clustered and quantized TFlite model: 9830.00 bytes

Veja a persistência da precisão de TF para TFLite

Defina uma função auxiliar para avaliar o modelo TFLite no conjunto de dados de teste.

 def eval_model(interpreter):
  input_index = interpreter.get_input_details()[0]["index"]
  output_index = interpreter.get_output_details()[0]["index"]

  # Run predictions on every image in the "test" dataset.
  prediction_digits = []
  for i, test_image in enumerate(test_images):
    if i % 1000 == 0:
      print('Evaluated on {n} results so far.'.format(n=i))
    # Pre-processing: add batch dimension and convert to float32 to match with
    # the model's input data format.
    test_image = np.expand_dims(test_image, axis=0).astype(np.float32)
    interpreter.set_tensor(input_index, test_image)

    # Run inference.
    interpreter.invoke()

    # Post-processing: remove batch dimension and find the digit with highest
    # probability.
    output = interpreter.tensor(output_index)
    digit = np.argmax(output()[0])
    prediction_digits.append(digit)

  print('\n')
  # Compare prediction results with ground truth labels to calculate accuracy.
  prediction_digits = np.array(prediction_digits)
  accuracy = (prediction_digits == test_labels).mean()
  return accuracy
 

Você avalia o modelo, que foi agrupado e quantizado e, em seguida, vê a precisão do TensorFlow persistir para o back-end do TFLite.

 interpreter = tf.lite.Interpreter(model_content=tflite_quant_model)
interpreter.allocate_tensors()

test_accuracy = eval_model(interpreter)

print('Clustered and quantized TFLite test_accuracy:', test_accuracy)
print('Clustered TF test accuracy:', clustered_model_accuracy)
 
Evaluated on 0 results so far.
Evaluated on 1000 results so far.
Evaluated on 2000 results so far.
Evaluated on 3000 results so far.
Evaluated on 4000 results so far.
Evaluated on 5000 results so far.
Evaluated on 6000 results so far.
Evaluated on 7000 results so far.
Evaluated on 8000 results so far.
Evaluated on 9000 results so far.


Clustered and quantized TFLite test_accuracy: 0.975
Clustered TF test accuracy: 0.9753000140190125

Conclusão

Neste tutorial, você viu como criar modelos em cluster com a API do TensorFlow Model Optimization Toolkit. Mais especificamente, você passou por um exemplo de ponta a ponta para criar um modelo 8x menor para o MNIST com diferença mínima de precisão. Recomendamos que você experimente esse novo recurso, que pode ser particularmente importante para implantação em ambientes com recursos limitados.