Geekly articles weekly

استعراض Keras ل TensorFlow



ترجمة دليل نظرة عامة من Tensorflow.org. يمنحك هذا الدليل الأساسيات للبدء في تطبيق Keras. القراءة تستغرق 10 دقائق.

استيراد tf.keras


tf.keras هو تطبيق لمواصفات TensorFlow Keras API. هذا هو واجهة برمجة التطبيقات عالية المستوى لبناء نماذج التدريب التي تتضمن دعمًا من الدرجة الأولى للوظائف الخاصة بـ TensorFlow مثل التنفيذ المتحمس ، وخطوط أنابيب tf.data ، tf.data . يجعل tf.keras استخدام TensorFlow أسهل دون التضحية بالمرونة والأداء.

للبدء ، قم باستيراد tf.keras كجزء من إعداد TensorFlow:

 from __future__ import absolute_import, division, print_function, unicode_literals import tensorflow as tf from tensorflow import keras

يمكن tf.keras تنفيذ أي كود متوافق مع Keras ، ولكن تذكر:

  • قد يختلف إصدار tf.keras في أحدث إصدار من TensorFlow عن أحدث إصدار من keras في PyPI. تحقق من tf.keras.__version__ .
  • عند حفظ أوزان النماذج ، يقوم tf.keras بذلك افتراضيًا بتنسيق نقطة تفتيش. مرر save_format='h5' لاستخدام HDF5 (أو أضف امتداد .h5 إلى .h5 الملف).

بناء نموذج بسيط


نموذج متسلسل


في Keras ، تقوم بجمع طبقات لبناء النماذج . النموذج عبارة عن رسم بياني للطبقة (عادة). أكثر أنواع النماذج شيوعًا هو رصة الطبقة: نموذج tf.keras.Sequential .

نحن نبني شبكة بسيطة متصلة بالكامل (أي مدركة متعددة الطبقات):

 from tensorflow.keras import layers model = tf.keras.Sequential() #       64 : model.add(layers.Dense(64, activation='relu')) #   : model.add(layers.Dense(64, activation='relu')) #   softmax  10 : model.add(layers.Dense(10, activation='softmax'))

تخصيص الطبقات


تتوفر العديد من أنواع طبقات tf.keras.layers . يستخدم معظمهم مُنشئ وسيطة شائع:

  • activation : يضبط وظيفة التنشيط للطبقة. تحدد هذه المعلمة اسم الوظيفة المضمنة أو الكائن الذي تم استدعاؤه. المعلمة لا يوجد لديه القيمة الافتراضية.
  • kernel_initializer و bias_initializer : مخططات التهيئة التي تنشئ أوزان الطبقة (الأساسية bias_initializer ). يمكن أن تكون هذه المعلمة اسم أو كائن يسمى. مهيئ الافتراضي هو "Glorot uniform" .
  • kernel_regularizer و bias_regularizer : تتم إضافة مخططات bias_regularizer إلى أوزان الطبقة (الأساسية bias_regularizer ) ، مثل L1 أو L2. بشكل افتراضي ، لم يتم ضبط التنظيم.

تستخدم الأمثلة التالية لمثيلات طبقات `tf.keras.layers.Dense` وسيطات المُنشئ:

 #    : layers.Dense(64, activation='sigmoid') # : layers.Dense(64, activation=tf.keras.activations.sigmoid) #     L1   0.01    : layers.Dense(64, kernel_regularizer=tf.keras.regularizers.l1(0.01)) #     L2   0.01    : layers.Dense(64, bias_regularizer=tf.keras.regularizers.l2(0.01)) #        : layers.Dense(64, kernel_initializer='orthogonal') #        2.0: layers.Dense(64, bias_initializer=tf.keras.initializers.Constant(2.0))

التدريب والتقييم


الإعداد التدريب


بعد تكوين النموذج ، قم بتكوين عملية التعلم عن طريق استدعاء طريقة compile :

 model = tf.keras.Sequential([ #     64   : layers.Dense(64, activation='relu', input_shape=(32,)), #  : layers.Dense(64, activation='relu'), #   softmax  10 : layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='categorical_crossentropy', metrics=['accuracy'])

يقبل tf.keras.Model.compile ثلاث وسائط مهمة:

  • optimizer : يحدد هذا الكائن الإجراء التدريب. قم بتمرير مثيلات محسن من الوحدة النمطية tf.keras.optimizers ، مثل tf.keras.optimizers.Adam أو tf.keras.optimizers.SGD . إذا كنت تريد فقط استخدام الخيارات الافتراضية ، فيمكنك أيضًا تحديد مُحسِّن مع كلمات رئيسية مثل 'adam' أو 'sgd' .
  • loss : هذه وظيفة يتم تصغيرها في عملية التعلم. من بين الاختلافات الشائعة الخطأ القياسي ( mse ) ، categorical_crossentropy ، binary_crossentropy . يتم تحديد وظائف الخسارة بالاسم أو بتمرير الكائن الذي تم استدعاؤه من الوحدة النمطية tf.keras.losses .
  • metrics : تستخدم لمراقبة التدريب. هذه أسماء سلسلة أو كائنات تسمى من الوحدة النمطية tf.keras.metrics .
  • بالإضافة إلى ذلك ، للتأكد من تدريب النموذج وتقييمه بشغف ، تحقق من تمرير المعلمة run_eagerly=True إلى المحول البرمجي

بعد ذلك ، سنرى بعض الأمثلة على تكوين النموذج للتدريب:

 #       . model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='mse', # mean squared error metrics=['mae']) # mean absolute error #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.01), loss=tf.keras.losses.CategoricalCrossentropy(), metrics=[tf.keras.metrics.CategoricalAccuracy()])

التعلم من بيانات NumPy


بالنسبة إلى مجموعات البيانات الأصغر ، استخدم صفيفات ذاكرة NumPy لتدريب وتقييم النموذج. يتم "تدريب" النموذج على بيانات التدريب باستخدام طريقة `fit`:

 import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.fit(data, labels, epochs=10, batch_size=32)

يأخذ tf.keras.Model.fit ثلاث وسائط مهمة:

  • epochs : التعلم مقسم إلى * الحلقات *. العصر عبارة عن تكرار واحد لكل بيانات الإدخال (يتم ذلك على دفعات صغيرة).
  • batch_size : عند إرسال بيانات batch_size ، يقسم النموذج البيانات إلى كتل أصغر (مجموعات) ويتكرر عبر هذه الكتل أثناء التدريب. يشير هذا الرقم إلى حجم كل كتلة بيانات. تذكر أن الكتلة الأخيرة قد تكون أصغر إذا لم يتم تقسيم العدد الإجمالي للسجلات على حجم الدُفعة.
  • validation_data : عند وضع النماذج الأولية للنموذج ، فأنت تريد أن تتبع أداءه بسهولة على بيانات التحقق من الصحة. يتيح تمرير مجموعة من بيانات الإدخال والتسميات باستخدام هذه الوسيطة للطراز عرض قيم وظيفة الخسارة والمقاييس في وضع الإخراج للبيانات التي يتم إرسالها في نهاية كل عصر.

فيما يلي مثال باستخدام validation_data :

 import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) val_data = np.random.random((100, 32)) val_labels = np.random.random((100, 10)) model.fit(data, labels, epochs=10, batch_size=32, validation_data=(val_data, val_labels))

التدريب باستخدام مجموعات بيانات tf.data


استخدم API Datasets لتغيير حجم قواعد البيانات الكبيرة أو التدريب عبر أجهزة متعددة. قم بتمرير مثيل `tf.data.Dataset` إلى طريقة fit :

 #    : dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.fit(dataset, epochs=10)

نظرًا لأن Dataset توفر البيانات على دفعات ، فإن هذا الجزء من الشفرة لا يتطلب وسيطة batch_size .

يمكن أيضًا استخدام مجموعات البيانات للتحقق من صحة:

 dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels)) val_dataset = val_dataset.batch(32) model.fit(dataset, epochs=10, validation_data=val_dataset)

التقييم والتنبؤ


يمكن أن تستخدم tf.keras.Model.predict tf.data.Dataset و tf.data.Dataset و tf.data.Dataset .

هذه هي الطريقة التي يمكنك بها تقدير الخسائر في وضع الإخراج ومقاييس البيانات المقدمة:

 #   Numpy data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.evaluate(data, labels, batch_size=32) #   dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.evaluate(dataset)

وإليك كيفية التنبؤ بإخراج المستوى الأخير في وضع الإخراج للبيانات المقدمة في شكل صفيف NumPy:

بناء نماذج معقدة


API الوظيفية


نموذج tf.keras.Sequential هو مكدس طبقة بسيط لا يمكنك تخيل نموذج اعتباطي. استخدم واجهة برمجة تطبيقات Keras الوظيفية لبناء طبولوجيا نموذج معقد ، مثل:

  • نماذج الإدخال متعددة
  • نماذج متعددة المخرجات ،
  • النماذج ذات الطبقات الشائعة (تسمى نفس الطبقة عدة مرات) ،
  • النماذج ذات تدفقات البيانات غير المتناسقة (مثل العلاقات المتبقية).

بناء نموذج مع API وظيفية يعمل على النحو التالي:

  1. مثيل الطبقة قابل للاستدعاء وإرجاع موتر.
  2. تُستخدم tf.keras.Model لتحديد مثيل tf.keras.Model
  3. تم تدريب هذا النموذج تمامًا مثل طراز "Sequential".

يستخدم المثال التالي واجهة برمجة التطبيقات الوظيفية لإنشاء شبكة بسيطة متصلة بالكامل:

 inputs = tf.keras.Input(shape=(32,)) #    #        . x = layers.Dense(64, activation='relu')(inputs) x = layers.Dense(64, activation='relu')(x) predictions = layers.Dense(10, activation='softmax')(x)

إنشاء مثيل للنموذج باستخدام هذه المدخلات والمخرجات.

 model = tf.keras.Model(inputs=inputs, outputs=predictions) #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5  model.fit(data, labels, batch_size=32, epochs=5)

نماذج فئة فرعية


قم بإنشاء نموذج قابل للتخصيص بالكامل باستخدام فئة فرعية tf.keras.Model وتحديد التوزيع المباشر الخاص بك. قم بإنشاء طبقات في طريقة __init__ وقم بتعيينها __init__ لمثيل الفئة. حدد الانتشار المباشر في طريقة call .

تعد الفئة الفرعية لنموذج مفيدًا بشكل خاص عند تمكين التنفيذ المتقن ، لأنه يتيح لك كتابة التوزيع المباشر بشكل حتمي.

ملاحظة: إذا كنت تريد تنفيذ النموذج الخاص بك دائمًا بشكل حتمي ، فيمكنك تعيين dynamic=True عند استدعاء المنشئ super .
النقطة الأساسية: استخدم واجهة برمجة التطبيقات الصحيحة للعمل. على الرغم من أن التصنيف الفرعي للنموذج يوفر المرونة ، إلا أنه يتعين عليك دفع ثمنه بمزيد من التعقيد وإمكانية أكبر للأخطاء المخصصة. إن أمكن ، اختر واجهة برمجة التطبيقات الوظيفية.
يُظهر المثال التالي نموذجًا tf.keras.Model فئة فرعية باستخدام توزيع مباشر مخصص ، وهو أمر غير مطلوب ليكون ضروريًا:

 class MyModel(tf.keras.Model): def __init__(self, num_classes=10): super(MyModel, self).__init__(name='my_model') self.num_classes = num_classes #    . self.dense_1 = layers.Dense(32, activation='relu') self.dense_2 = layers.Dense(num_classes, activation='sigmoid') def call(self, inputs): #     , #      ( `__init__`). x = self.dense_1(inputs) return self.dense_2(x)

إنشاء مثيل لفئة الطراز الجديد:

 model = MyModel(num_classes=10) #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5 . model.fit(data, labels, batch_size=32, epochs=5)

طبقات مخصصة


قم بإنشاء طبقة مخصصة عن طريق التصنيف الفرعي tf.keras.layers.Layer وتطبيق الطرق التالية:

  • __init__ : حدد بشكل اختياري الطبقات الفرعية التي سيتم استخدامها في هذه الطبقة.
  • * build : إنشاء طبقة الأوزان. إضافة الأوزان باستخدام طريقة add_weight
  • call : تحديد التوزيع المباشر.
  • اختياريًا ، يمكن إجراء تسلسل للطبقة من خلال تطبيق أسلوب get_config وطريقة الفئة from_config .

فيما يلي مثال لطبقة المستخدم التي تضاعف المصفوفة ( matmul ) التي تغذيها المدخلات بمصفوفة kernel:

 class MyLayer(layers.Layer): def __init__(self, output_dim, **kwargs): self.output_dim = output_dim super(MyLayer, self).__init__(**kwargs) def build(self, input_shape): #       . self.kernel = self.add_weight(name='kernel', shape=(input_shape[1], self.output_dim), initializer='uniform', trainable=True) def call(self, inputs): return tf.matmul(inputs, self.kernel) def get_config(self): base_config = super(MyLayer, self).get_config() base_config['output_dim'] = self.output_dim return base_config @classmethod def from_config(cls, config): return cls(**config)

قم بإنشاء نموذج باستخدام الطبقة المخصصة الخاصة بك:

 model = tf.keras.Sequential([ MyLayer(10), layers.Activation('softmax')]) #      model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5 . model.fit(data, labels, batch_size=32, epochs=5)

الاسترجاعات


Kolbek هو كائن تم نقله إلى النموذج لتخصيص وتوسيع سلوكه أثناء التدريب. يمكنك كتابة رد الاتصال المخصص الخاص بك أو استخدام tf.keras.callbacks والذي يتضمن:

tf.keras.callbacks.ModelCheckpoint : حفظ نقاط توقف النموذج على فترات زمنية منتظمة.
tf.keras.callbacks.LearningRateScheduler : قم بتغيير خطوة التعلم ديناميكيًا.
tf.keras.callbacks.EarlyStopping : إيقاف التدريب عندما تتوقف نتيجة التحقق من الصحة عن التحسن.
tf.keras.callbacks.TensorBoard: مراقبة سلوك النموذج باستخدام
TensorBoard

لاستخدام tf.keras.callbacks.Callback ، tf.keras.callbacks.Callback إلى طريقة الطراز fit :

 callbacks = [ #    `val_loss`     2  tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'), #   TensorBoard   `./logs` directory tf.keras.callbacks.TensorBoard(log_dir='./logs') ] model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks, validation_data=(val_data, val_labels))

حفظ واستعادة


حفظ قيم الوزن فقط


حفظ وتحميل أوزان النماذج باستخدام tf.keras.Model.save_weights :

 model = tf.keras.Sequential([ layers.Dense(64, activation='relu', input_shape=(32,)), layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='categorical_crossentropy', metrics=['accuracy']) 

 #     TensorFlow Checkpoint model.save_weights('./weights/my_model') #    #        . model.load_weights('./weights/my_model')

بشكل افتراضي ، يتم حفظ أوزان النماذج في تنسيق نقطة تفتيش TensorFlow. يمكن أيضًا حفظ الأوزان بتنسيق Keras HDF5 (القيمة الافتراضية لتطبيق Keras العالمي):

 #     HDF5 model.save_weights('my_model.h5', save_format='h5') #    model.load_weights('my_model.h5')

حفظ تكوين النموذج فقط


يمكن حفظ تكوين النموذج - وهذا يؤدي إلى تسلسل بنية النموذج دون أي أوزان. يمكن للتهيئة المحفوظة استعادة نفس النموذج وتهيئته ، حتى بدون رمز يحدد النموذج الأصلي. تدعم Keras تنسيقات تسلسل JSON و YAML:

 #     JSON json_string = model.to_json() json_string 

 import json import pprint pprint.pprint(json.loads(json_string))

استعادة نموذج (إعادة تهيئة) من JSON:

 fresh_model = tf.keras.models.model_from_json(json_string)

يتطلب تسلسل النموذج إلى YAML تثبيت `pyyaml` قبل استيراد TensorFlow :

 yaml_string = model.to_yaml() print(yaml_string)

استعادة نموذج من YAML:

 fresh_model = tf.keras.models.model_from_yaml(yaml_string)

ملاحظة: النماذج غير المصنفة تحت فئة غير قابلة للتسلسل ، لأن بنيتها محددة بواسطة كود Python في نص أسلوب `call`.

حفظ النموذج بأكمله في ملف واحد


يمكن حفظ النموذج بأكمله في ملف يحتوي على قيم الأوزان وتكوين النموذج وحتى تكوين المحسن. سيتيح لك ذلك تعيين نقطة توقف نموذجية ومواصلة التدريب لاحقًا من نفس الموضع تمامًا حتى بدون الوصول إلى الكود المصدر.

 #    model = tf.keras.Sequential([ layers.Dense(10, activation='softmax', input_shape=(32,)), layers.Dense(10, activation='softmax') ]) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(data, labels, batch_size=32, epochs=5) #      HDF5 model.save('my_model.h5') #         . model = tf.keras.models.load_model('my_model.h5')

تنفيذ حريصة


التنفيذ المتقن هو بيئة برمجة ضرورية تنفذ العمليات على الفور. هذا غير مطلوب لـ Keras ، ولكن مدعوم من tf.keras وهو مفيد للتحقق من البرنامج وتصحيح الأخطاء.

جميع نماذج بناء واجهة برمجة تطبيقات `tf.keras` متوافقة مع التنفيذ المتشوق. على الرغم من إمكانية استخدام واجهات برمجة التطبيقات (API) التتابعية والوظيفية ، إلا أن التنفيذ المتقن يفيد بشكل خاص عند تصنيف فئة فرعية وإنشاء طبقات مخصصة - تتطلب واجهات برمجة التطبيقات هذه كتابة توزيع مباشر في شكل شفرة (بدلاً من واجهات برمجة التطبيقات التي تنشئ نماذج من خلال تجميع الطبقات الموجودة).

توزيع


GPUs متعددة


يمكن تشغيل نماذج tf.keras على وحدات معالجة tf.distribute.Strategy متعددة باستخدام tf.distribute.Strategy . يوفر هذا API التعلم الموزع عبر وحدات معالجة الرسومات متعددة مع تغيير طفيف أو لا تغيير على التعليمات البرمجية الموجودة.

حاليًا ، tf.distribute.MirroredStrategy استراتيجية التوزيع الوحيدة المدعومة. MirroredStrategy يكرر الرسومات مع
التعلم المتزامن باستخدام الكل في جهاز واحد. لاستخدام ` distribute.Strategy ، قم بتثبيت محسِّن التصميم وتصميمه وتجميعه في" Strategy " .scope() ` ، ثم قم بتدريب النموذج.

المثال التالي يوزع tf.keras.Model بين وحدات معالجة الرسومات المتعددة على نفس الجهاز.

أولاً ، نحدد نموذجًا في مجال الاستراتيجية الموزعة:

 strategy = tf.distribute.MirroredStrategy() with strategy.scope(): model = tf.keras.Sequential() model.add(layers.Dense(16, activation='relu', input_shape=(10,))) model.add(layers.Dense(1, activation='sigmoid')) optimizer = tf.keras.optimizers.SGD(0.2) model.compile(loss='binary_crossentropy', optimizer=optimizer) model.summary()

ثم نقوم بتدريب النموذج على البيانات كالمعتاد:

 x = np.random.random((1024, 10)) y = np.random.randint(2, size=(1024, 1)) x = tf.cast(x, tf.float32) dataset = tf.data.Dataset.from_tensor_slices((x, y)) dataset = dataset.shuffle(buffer_size=1024).batch(32) model.fit(dataset, epochs=1)

بعد التحقق ، ستظهر الترجمة أيضًا على Tensorflow.org. إذا كنت ترغب في المشاركة في ترجمة وثائق موقع Tensorflow.org إلى اللغة الروسية ، يرجى الاتصال في رسالة شخصية أو تعليقات. هي موضع تقدير أي تصحيحات أو تعليقات.

Source: https://habr.com/ru/post/ar482126/

More articles:


All Articles