این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.
Switch to English

خوشه بندی وزن در نمونه کراس

مشاهده در TensorFlow.org در Google Colab اجرا کنید مشاهده منبع در GitHub بارگیری نوت بوک

بررسی اجمالی

به عنوان مثال انتهای پایان برای خوشهای وزن ، بخشی از ابزار بهینه سازی مدل TensorFlow خوش آمدید.

صفحات دیگر

برای آشنایی با خوشه بندی وزن و تعیین اینکه آیا شما باید از آن استفاده کنید (از جمله آنچه پشتیبانی می شود) ، به صفحه مروری مراجعه کنید .

برای پیدا کردن سریع API های مورد نیاز خود (فراتر از خوشه بندی کامل یک مدل با 16 خوشه) ، به راهنمای جامع مراجعه کنید.

فهرست

در این آموزش ،

  1. آموزش مدل tf.keras برای مجموعه داده MNIST از ابتدا.
  2. مدل را با استفاده از API خوشه بندی وزنه تنظیم کرده و دقت را ببینید.
  3. یک مدل TF و TFLite 6 برابر کوچکتر از خوشه بندی ایجاد کنید.
  4. یک مدل TFLite 8 برابر کوچکتر از ترکیب وزن خوشه ای و کمیت سنجی پس از آموزش ایجاد کنید.
  5. تداوم دقت از TF تا TFLite را مشاهده کنید.

برپایی

می توانید این نوت بوک Jupyter را در virtualenv یا colab محلی خود اجرا کنید. برای جزئیات تنظیم وابستگی ، به راهنمای نصب مراجعه کنید.

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

import numpy as np
import tempfile
import zipfile
import os
 

آموزش یک مدل tf.keras برای MNIST بدون خوشه بندی

 # 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>

مدل پایه را ارزیابی کرده و آن را برای استفاده بعدی ذخیره کنید

 _, 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

مدل های از قبل آموزش داده شده را با خوشه بندی تنظیم کنید

API cluster_weights() را بر روی یک مدل کامل از پیش آموزش داده شده اعمال کنید تا اثربخشی آن در کاهش اندازه مدل بعد از اعمال زیپ را نشان داده و ضمن حفظ دقت مناسب. برای اینکه به بهترین نحو تعادل بین دقت و سرعت فشرده سازی را برای مورد استفاده خود داشته باشید ، لطفاً به عنوان مثال در هر لایه در راهنمای جامع مراجعه کنید .

تعریف مدل و اعمال API خوشه ای

قبل از اینکه مدل را به API خوشه بندی منتقل کنید ، مطمئن شوید که آموزش دیده است و دقت قابل قبولی را نشان می دهد.

 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
_________________________________________________________________

مدل را مرتب کرده و دقت را در برابر خط پایه ارزیابی کنید

مدل را با خوشه بندی برای 1 دوره تنظیم کنید.

 # 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>

برای این مثال ، در مقایسه با پایه ، حداقل دقت در تست پس از خوشه بندی وجود دارد.

 _, 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

6 برابر مدل های کوچکتر از خوشه بندی ایجاد کنید

برای دیدن مزایای فشرده سازی خوشه سازی ، هر دو strip_clustering و استفاده از یک الگوریتم فشرده سازی استاندارد (به عنوان مثال از طریق gzip) ضروری هستند.

ابتدا یک مدل فشرده شده برای TensorFlow ایجاد کنید. در اینجا ، strip_clustering تمام متغیرها را حذف می کند (به عنوان مثال tf.Variable برای ذخیره سازی tf.Variable های خوشه ای و شاخص ها) که خوشه بندی فقط در طول آموزش نیاز دارد ، که در غیر این صورت می تواند به اندازه مدل در طول استنباط باشد.

 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

سپس ، مدل های فشرده سازی را برای TFLite ایجاد کنید. می توانید مدل خوشهای را به فرمی تبدیل کنید که در باطن هدفمند شما قابل اجرا است. TensorFlow Lite نمونه ای است که می توانید برای اعزام به دستگاه های تلفن همراه استفاده کنید.

 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

عملکرد کمکی را تعریف کنید تا در واقع فشرده سازی مدل ها از طریق gzip و اندازه فشرده شده اندازه گیری شود.

 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)
 

مقایسه کنید و ببینید که مدل ها از خوشه بندی 6 برابر کوچکتر هستند

 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

یک مدل TFLite 8 برابر کوچکتر از ترکیب وزن خوشه ای و کمیت سنجی پس از آموزش ایجاد کنید

برای مزایای اضافی می توانید از کمیت بعد از آموزش به مدل خوشهای استفاده کنید.

 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

تداوم دقت از TF تا TFLite را مشاهده کنید

برای ارزیابی مدل TFLite در مجموعه داده آزمون ، یک تابع کمکی را تعریف کنید.

 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
 

شما این مدل را ارزیابی می کنید ، که به صورت خوشه ای و اندازه گیری شده است ، و سپس دقت از ادامه کار TensorFlow تا باطن 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

نتیجه

در این آموزش دیدید که چگونه می توانید مدل های خوشهای را با API Toolkit Optimization TensorFlow Model Optimization ایجاد کنید. به طور خاص ، شما برای ایجاد یک مدل 8 برابر کوچکتر برای MNIST با یک اختلاف حداقل دقت ، از نمونه ای برای پایان استفاده کرده اید. ما شما را تشویق می کنیم این قابلیت جدید را امتحان کنید ، که می تواند برای استقرار در محیط های دارای محدودیت منابع بسیار مهم باشد.