Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Umfassende Anleitung zum Weight Clustering

Ansicht auf TensorFlow.org Führen Sie in Google Colab aus Quelle auf GitHub anzeigen Notizbuch herunterladen

Willkommen zum umfassenden Leitfaden für Gewichtsclustering , der Teil des TensorFlow-Modelloptimierungs-Toolkits ist.

Diese Seite dokumentiert verschiedene Anwendungsfälle und zeigt, wie die API für jeden verwendet wird. Wenn Sie wissen, welche APIs Sie benötigen, finden Sie die Parameter und die Details auf niedriger Ebene in den API-Dokumenten :

  • Wenn Sie die Vorteile von Weight Clustering und die unterstützten Funktionen sehen möchten, überprüfen Sie die Übersicht .
  • Ein einzelnes End-to-End-Beispiel finden Sie im Beispiel für Gewichtsclustering .

In diesem Handbuch werden die folgenden Anwendungsfälle behandelt:

  • Definieren Sie ein Cluster-Modell.
  • Überprüfen Sie ein Cluster-Modell und deserialisieren Sie es.
  • Verbessern Sie die Genauigkeit des Cluster-Modells.
  • Nur für die Bereitstellung müssen Sie Schritte ausführen, um die Vorteile der Komprimierung zu sehen.

Installieren

! pip install -q tensorflow-model-optimization

import tensorflow as tf
import numpy as np
import tempfile
import os
import tensorflow_model_optimization as tfmot

input_dim = 20
output_dim = 20
x_train = np.random.randn(1, input_dim).astype(np.float32)
y_train = tf.keras.utils.to_categorical(np.random.randn(1), num_classes=output_dim)

def setup_model():
  model = tf.keras.Sequential([
      tf.keras.layers.Dense(input_dim, input_shape=[input_dim]),
      tf.keras.layers.Flatten()
  ])
  return model

def train_model(model):
  model.compile(
      loss=tf.keras.losses.categorical_crossentropy,
      optimizer='adam',
      metrics=['accuracy']
  )
  model.summary()
  model.fit(x_train, y_train)
  return model

def save_model_weights(model):
  _, pretrained_weights = tempfile.mkstemp('.h5')
  model.save_weights(pretrained_weights)
  return pretrained_weights

def setup_pretrained_weights():
  model= setup_model()
  model = train_model(model)
  pretrained_weights = save_model_weights(model)
  return pretrained_weights

def setup_pretrained_model():
  model = setup_model()
  pretrained_weights = setup_pretrained_weights()
  model.load_weights(pretrained_weights)
  return model

def save_model_file(model):
  _, keras_file = tempfile.mkstemp('.h5') 
  model.save(keras_file, include_optimizer=False)
  return keras_file

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

  keras_file = save_model_file(model)

  _, zipped_file = tempfile.mkstemp('.zip')
  with zipfile.ZipFile(zipped_file, 'w', compression=zipfile.ZIP_DEFLATED) as f:
    f.write(keras_file)
  return os.path.getsize(zipped_file)

setup_model()
pretrained_weights = setup_pretrained_weights()
WARNING: You are using pip version 20.2.2; however, version 20.2.3 is available.
You should consider upgrading via the '/tmpfs/src/tf_docs_env/bin/python -m pip install --upgrade pip' command.
Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_1 (Dense)              (None, 20)                420       
_________________________________________________________________
flatten_1 (Flatten)          (None, 20)                0         
=================================================================
Total params: 420
Trainable params: 420
Non-trainable params: 0
_________________________________________________________________
1/1 [==============================] - 0s 1ms/step - loss: 16.1181 - accuracy: 0.0000e+00

Definieren Sie ein Cluster-Modell

Cluster ein ganzes Modell (sequentiell und funktional)

Tipps für eine bessere Modellgenauigkeit:

  • Sie müssen ein vorab trainiertes Modell mit akzeptabler Genauigkeit an diese API übergeben. Das Trainieren von Modellen von Grund auf mit Clustering führt zu einer unterdurchschnittlichen Genauigkeit.
  • In einigen Fällen wirkt sich das Clustering bestimmter Schichten nachteilig auf die Modellgenauigkeit aus. Aktivieren Sie "Cluster einige Ebenen", um zu sehen, wie Sie das Clustering der Ebenen überspringen, die die Genauigkeit am meisten beeinflussen.

tfmot.clustering.keras.cluster_weights auf das Modell an, um alle Ebenen zu tfmot.clustering.keras.cluster_weights .

import tensorflow_model_optimization as tfmot

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

clustering_params = {
  'number_of_clusters': 3,
  'cluster_centroids_init': CentroidInitialization.DENSITY_BASED
}

model = setup_model()
model.load_weights(pretrained_weights)

clustered_model = cluster_weights(model, **clustering_params)

clustered_model.summary()
Model: "sequential_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
cluster_dense_2 (ClusterWeig (None, 20)                423       
_________________________________________________________________
cluster_flatten_2 (ClusterWe (None, 20)                0         
=================================================================
Total params: 423
Trainable params: 23
Non-trainable params: 400
_________________________________________________________________

Cluster einige Schichten (sequentielle und funktionale Modelle)

Tipps für eine bessere Modellgenauigkeit:

  • Sie müssen ein vorab trainiertes Modell mit akzeptabler Genauigkeit an diese API übergeben. Das Trainieren von Modellen von Grund auf mit Clustering führt zu einer unterdurchschnittlichen Genauigkeit.
  • Cluster späterer Schichten mit redundanteren Parametern (z. B. tf.keras.layers.Dense , tf.keras.layers.Conv2D ) im Gegensatz zu den frühen Schichten.
  • Frieren Sie frühe Schichten vor den gruppierten Schichten während der Feinabstimmung ein. Behandeln Sie die Anzahl der gefrorenen Schichten als Hyperparameter. Empirisch gesehen ist das Einfrieren der meisten frühen Schichten ideal für die aktuelle Clustering-API.
  • Vermeiden Sie das Clustering kritischer Schichten (z. B. Aufmerksamkeitsmechanismus).

Weitere tfmot.clustering.keras.cluster_weights : Die API-Dokumente zu tfmot.clustering.keras.cluster_weights Details zum tfmot.clustering.keras.cluster_weights der tfmot.clustering.keras.cluster_weights pro Schicht.

# Create a base model
base_model = setup_model()
base_model.load_weights(pretrained_weights)

# Helper function uses `cluster_weights` to make only 
# the Dense layers train with clustering
def apply_clustering_to_dense(layer):
  if isinstance(layer, tf.keras.layers.Dense):
    return cluster_weights(layer, **clustering_params)
  return layer

# Use `tf.keras.models.clone_model` to apply `apply_clustering_to_dense` 
# to the layers of the model.
clustered_model = tf.keras.models.clone_model(
    base_model,
    clone_function=apply_clustering_to_dense,
)

clustered_model.summary()
Model: "sequential_3"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
cluster_dense_3 (ClusterWeig (None, 20)                423       
_________________________________________________________________
flatten_3 (Flatten)          (None, 20)                0         
=================================================================
Total params: 423
Trainable params: 23
Non-trainable params: 400
_________________________________________________________________

Überprüfen Sie ein Cluster-Modell und deserialisieren Sie es

Ihr Anwendungsfall: Dieser Code wird nur für das HDF5-Modellformat benötigt (keine HDF5-Gewichte oder andere Formate).

# Define the model.
base_model = setup_model()
base_model.load_weights(pretrained_weights)
clustered_model = cluster_weights(base_model, **clustering_params)

# Save or checkpoint the model.
_, keras_model_file = tempfile.mkstemp('.h5')
clustered_model.save(keras_model_file, include_optimizer=True)

# `cluster_scope` is needed for deserializing HDF5 models.
with tfmot.clustering.keras.cluster_scope():
  loaded_model = tf.keras.models.load_model(keras_model_file)

loaded_model.summary()
WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.
Model: "sequential_4"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
cluster_dense_4 (ClusterWeig (None, 20)                423       
_________________________________________________________________
cluster_flatten_4 (ClusterWe (None, 20)                0         
=================================================================
Total params: 423
Trainable params: 23
Non-trainable params: 400
_________________________________________________________________

Verbessern Sie die Genauigkeit des Cluster-Modells

Für Ihren speziellen Anwendungsfall gibt es Tipps, die Sie berücksichtigen können:

  • Die Schwerpunktinitialisierung spielt eine Schlüsselrolle für die endgültige optimierte Modellgenauigkeit. Im Allgemeinen übertrifft die lineare Initialisierung die Dichte und die zufällige Initialisierung, da sie nicht dazu neigt, große Gewichte zu übersehen. Es wurde jedoch beobachtet, dass eine Dichteinitialisierung eine bessere Genauigkeit für den Fall der Verwendung sehr weniger Cluster auf Gewichten mit bimodalen Verteilungen ergibt.

  • Stellen Sie eine Lernrate ein, die niedriger ist als die im Training verwendete, um das Cluster-Modell zu optimieren.

  • Allgemeine Ideen zur Verbesserung der Modellgenauigkeit finden Sie unter "Definieren eines Cluster-Modells" unter Tipps für Ihre Anwendungsfälle.

Einsatz

Modell mit Größenkomprimierung exportieren

Häufiger Fehler : Sowohl strip_clustering als auch die Anwendung eines Standardkomprimierungsalgorithmus (z. B. über gzip) sind erforderlich, um die Komprimierungsvorteile von Clustering zu erkennen.

model = setup_model()
clustered_model = cluster_weights(model, **clustering_params)

clustered_model.compile(
    loss=tf.keras.losses.categorical_crossentropy,
    optimizer='adam',
    metrics=['accuracy']
)

clustered_model.fit(
    x_train,
    y_train
)

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

print("final model")
final_model.summary()

print("\n")
print("Size of gzipped clustered model without stripping: %.2f bytes" 
      % (get_gzipped_model_size(clustered_model)))
print("Size of gzipped clustered model with stripping: %.2f bytes" 
      % (get_gzipped_model_size(final_model)))
1/1 [==============================] - 0s 984us/step - loss: 16.1181 - accuracy: 0.0000e+00
final model
Model: "sequential_5"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_5 (Dense)              (None, 20)                420       
_________________________________________________________________
flatten_5 (Flatten)          (None, 20)                0         
=================================================================
Total params: 420
Trainable params: 420
Non-trainable params: 0
_________________________________________________________________


Size of gzipped clustered model without stripping: 1809.00 bytes
Size of gzipped clustered model with stripping: 1399.00 bytes