Ali Haidar Ahmad

الموديول tf.app.flags هو تابع توفره Tensorflow لتنفيذ ال "command line flags" أي إشارات سطر الأوامر لكود Tensorflow الخاص بك. على سبيل المثال ، فإن الكود الذي صادفته سيقوم بما يلي:
flags.DEFINE_float('learning_rate', 0.01, 'Initial learning rate.') تحدد الوسيطة الأولى اسم العلامة flag بينما تحدد الثانية القيمة الافتراضية في حالة عدم تحديد العلامة flag أثناء تنفيذ الملف. لذلك إذا قمت بتشغيل ما يلي:
$ python fully_connected_feed.py --learning_rate 1.00 سيتم ضبط معدل التعلم على 1.00 وسيبقى 0.01 إذا لم يتم تحديد قيمة للعلم flag.
ومايزال تجريبي لذا قد لاتجد توثيقاً لذا يوصى بتنفيذ تحليل العلم "flag parsing" باستخدام argparse أو أي مكتبة أخرى تفضلها.

يدعم Keras الإيقاف المبكر للتدريب عن طريق callback يسمى EarlyStopping. ويسمح لنا بتحديد مقياس الأداء الذي نريد أن تتم مراقبته، ليتم إيقاف التدريب عند توقف هذا المقياس عن التحسن.(مثلاً عندما تتوقف ال validation accuracy  عن التحسن يقوم النموذج بإيقاف التدريب تلقائياً). تعتمد فكرته على أنه طالما مازالت قيمة المعيار تتحسن سنستمر بالتدريب وبمجرد توقفها عن التحسن (أي تراجعت قيمتها مثلاً في حالة اخترنا المقياس Accuracy وكانت دقة التدريب في مرحلة ما 0.8 ثم في ال epoch التالي تراجعت قيمته لل 0.79 ستم إيقاف التدريب وهنا ستظهر لنا مشكلة سأتحدث عنها في *) .إن استخدام تكنيك التوقف المبكر يتطلب أن يكون لديك validation_data قمت بتحديدها مسبقاً لأننا نطبقه على أساس قيمها وإلا لن يكون لاستخدامه معنى. وكما تعلم هناك طريقتين لنقوم بتحديد ال validation الأولى بأن نحددها من خلال قسم جزء من داتا التدريب باستخدام الوسيطة validation_split:
model.fit(train_X, train_y, validation_split=0.3) أو أن تكون لدينا بيانات جاهزة:
model.fit(train_X, train_y, validation_data=(val_x, val_y)) يتم تكوين ال EarlyStopping عند إنشاء غرض منه وتمريره للوسيطة callback في الدالة fit. ومن خلال الوسيطة "monitor" نقوم بتحديد مقياس الأداء المراد مراقبته من أجل إنهاء التدريب:
es = EarlyStopping(monitor='val_loss') بناءً على اختيار مقياس الأداء، يجب تحديد وسيطة "mode" وذلك لتحديد فيما إذا كان الهدف من المقياس المختار هو الزيادة (التكبير أو "الحد الأقصى") أو تقليله (تقليل أو "الحد الأدنى"). على سبيل المثال، سنسعى للحصول على حد أدنى لل validation loss، بينما سنسعى إلى الحد الأقصى لل val_acc.
es = EarlyStopping(monitor='val_loss', mode='min') بشكل افتراضي ، يتم تعيين الوضع على "auto" وسيعرف أنك تريد التقليل في حالة ال loss أو زيادة الدقة إلى أقصى حد في حالة ال accuracy.
وإذا أردت طباعة رقم ال epoch الذي توقف عنده التدريب فقط نضبط verbose على 1.
es = EarlyStopping(monitor='val_loss', mode='min', verbose=1) الآن سأتحدث عن المشكلة التي أشرت لها في *، وهي "كانت دقة التدريب في مرحلة ما 0.8 ثم في ال epoch التالي تراجعت قيمته لل 0.79 ستم إيقاف التدريب" في هكذا حالة فإن إيقاف التدريب سيكون أمر خاطئ لأنه ربما في الحقبتين التاليتين سيعود للتحسن وبشكل كبير جداً، أي قد يكون النموذج قد وقع مثلاً في قيمة صغرى محلية ويحتاج للصبر قليلاً لكي يخرج منها ثم يعود للتحسن، وهنا يأتي دور الوسيطة patience والتي تمثل "الصبر" أي أصبر عليها لفترة محددة إذا لم تتحسن توقف:
es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) # epoch هنا سينتظر 4 أخيرًا ، قد يكون من المستحسن التوقف عن التدريب فقط إذا ظل الأداء أعلى أو أقل من عتبة معينة أو خط أساس معين. على سبيل المثال ، إذا كان لديك إلمام بتدريب النموذج (مثل منحنيات التعلم) وتعلم أنه بمجرد تحقيق validation loss بقيمة معينة ، فلا فائدة من استمرار التدريب. يمكن تحديد ذلك عن طريق تعيين وسيطة "baseline".
es = EarlyStopping(monitor='val_loss', mode='min', baseline=0.4) مثال كامل:
from sklearn.datasets import make_moons from keras.models import Sequential from keras.layers import Dense from keras.callbacks import EarlyStopping from keras.callbacks import ModelCheckpoint from matplotlib import pyplot from keras.models import load_model # توليد بيانات ثنائية الأبعاد للتجربة عليها X, y = make_moons(n_samples=100, noise=0.2, random_state=1) # split into train and test n_train = 30 trainX, testX = X[:n_train, :], X[n_train:, :] trainy, testy = y[:n_train], y[n_train:] # define model model = Sequential() model.add(Dense(500, input_dim=2, activation='relu')) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # simple early stopping es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=200) # لحفظ أفضل نتيجة حصلنا عليها خلال التدريب mc = ModelCheckpoint('best_model.h5', monitor='val_accuracy', mode='max', verbose=1, save_best_only=True) # fit model history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=4000, verbose=0, callbacks=[es, mc]) # load the saved model saved_model = load_model('best_model.h5') # evaluate the model _, train_acc = saved_model.evaluate(trainX, trainy, verbose=0) _, test_acc = saved_model.evaluate(testX, testy, verbose=0) print('Train: %.3f, Test: %.3f' % (train_acc, test_acc))  

في Tensorflow 2.x (2.1) ، يمكنك الحصول على أبعاد (شكل) الموتر كقيم عدد صحيح ، من خلال tf.shape كما هو موضح في الكود أدناه:
import tensorflow as tf c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) Shape = c.shape.as_list() print(Shape) # [2,3] أو من خلال tf.get_shape() :
import tensorflow as tf c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) Shape = c.get_shape().as_list() print(Shape) # [2,3] أو بكود عادي (دون استخدام الدوال الجاهزة في المكتبة):
rows, columns = map(lambda i: i.value, tensor.get_shape())  

أولاً سأبدأ بهذه الملاحظة: اعتباراً من الإصدار 0.11 ، تم إهمال كل من op_scope و variable_op_scope واستبدالهما بـ name_scope و variable_scope.
دعنا نتكلم أولاً عن مفهوم ال variable sharing في TensorFlow: هو آلية تسمح لنا بمشاركة المتغيرات التي يتم الوصول إليها في أجزاء مختلفة من الكود دون تمرير مراجع إلى المتغير. يمكننا استخدام الطريقة tf.get_variable مع اسم المتغير كوسيطة لإنشاء متغير جديد بهذا الاسم أو استرداد المتغير الذي تم إنشاؤه من قبل. وهذا يختلف عن استخدام tf.Variable constructor الذي سينشئ متغيراً جديداً في كل مرة يتم استدعاؤه (ويحتمل أن يضيف لاحقة إلى اسم المتغير إذا كان متغير بهذا الاسم موجوداً بالفعل). ولغرض آلية المشاركة المتغيرة ، تم تقديم نوع منفصل من النطاق (نطاق متغير). نتيجة لذلك ، تم وضع نوعين مختلفين من النطاقات: أولاً، نطاق الاسم ، يتم إنشاؤه باستخدام tf.name_scope، ثانياً، نطاق متغير ، يتم إنشاؤه باستخدام tf.variable_scope . كلا النطاقين لهما نفس التأثير على جميع العمليات وكذلك المتغيرات التي تم إنشاؤها باستخدام متغير tf، أي سيتم إضافة النطاق كبادئة إلى العملية أو اسم المتغير. ومع ذلك ، يتم تجاهل نطاق الاسم بواسطة tf.get_variable. يمكننا أن نرى ذلك في المثال التالي: الطريقة الوحيدة لوضع متغير يتم الوصول إليه باستخدام tf.get_variable في نطاق هو استخدام نطاق متغير ، كما في المثال التالي: 
with tf.name_scope("scope"): variable1 = tf.get_variable("variable1", [1], dtype=tf.float64) variable2 = tf.Variable(1, name="variable2", dtype=tf.float64) op = tf.add(variable1, variable2) # scope/Add:0 op.name # variable1:0 variable1.name # scope/variable2:0 variable2.name الطريقة الوحيدة لوضع متغير يتم الوصول إليه باستخدام tf.get_variable في نطاق هو استخدام نطاق متغير ، كما في المثال التالي:
with tf.name_scope("scope"): variable1 = tf.get_variable("variable1", [1], dtype=tf.float64) variable2 = tf.Variable(1, name="variable2", dtype=tf.float64) op = tf.add(variable1, variable2) # scope/Add:0 op.name # scope/variable1:0 variable1.name # scope/variable2:0 variable2.name يتيح لنا ذلك مشاركة المتغيرات بسهولة عبر أجزاء مختلفة من البرنامج ، حتى ضمن نطاقات الأسماء المختلفة:
with tf.name_scope("bla"): with tf.variable_scope("scope"): var = tf.get_variable("variable", [1]) with tf.name_scope("blabla"): with tf.variable_scope("scope", reuse=True): var1 = tf.get_variable("variable", [1]) assert var1 == var var.name # scope/variable:0 var1.name # scope/variable:0

عند استخدامها مع virtualenv ، سيتم تثبيت الحزم في المسار:
<virtualenv_name>/lib/<python_ver>/site-packages وبشكل عام كل مايتم تثبيته من خلال pip يمكنك العثور عليه من خلال:
pip show <package name> مثال:
(base) C:\Users\Windows.10>pip show cvxopt WARNING: Package(s) not found: cvxopt (base) C:\Users\Windows.10>pip show numpy Name: numpy Version: 1.19.5 Summary: NumPy is the fundamental package for array computing with Python. Home-page: https://www.numpy.org Author: Travis E. Oliphant et al. Author-email: None License: BSD Location: c:\users\windows.10\anaconda3\lib\site-packages Requires: Required-by: transformers, torchvision, torch, thinc, tensorflow, tensorboardX, tensorboard, tables, streamlit, statsmodels, spacy, simpletransformers, seqeval, seaborn, scipy, scikit-learn, PyWavelets, pytest-arraydiff, pydeck, pyarrow, patsy, pandas, opt-einsum, opencv-python, numexpr, numba, mkl-random, mkl-fft, matplotlib, Keras, Keras-Preprocessing, imageio, h5py, gensim, easyocr, datasets, Bottleneck, bokeh, blis, bkcharts, astropy, altair  

OneToOneField يمثل علاقة (one-to-one) ويمثل مفهوم ال composition (التركيب) في الكائنات object، بينما ForeignKey  يمثل (one-to-many)  ويمثل مفهوم ال agregation أو التجميع للكائنات.
OneToOneField هي علاقة واحد لواحد كما ذكرنا وهي مشابهة لحالة ForeignKey  مع تحديد قيمة unique على True، ولكن في حالة reverse سيعيد كائناً واحداً مباشرةً. أما ForeignKey  فستعيد QuerySet.
(one-to-one field )(one-to-one)== (ForeignKey with unique=True)(one-to-many) ForeignKey ="reverse" relation returns a QuerySet. # وستعيد QuerySet one-to-one field = "reverse" يعيد كائن واحد مباشرةً سأعطيك الآن مثال عملي لتفهمهم بشكل أفضل. افترض للحظة أنك تريد إنشاء مدونة في django حيث يمكن للصحفيين كتابة المقالات الإخبارية ونشرها. يريد مالك الصحيفة الإلكترونية أن يسمح لكل من مراسليه بنشر العديد من المقالات التي يريدونها ، لكنه لا يريد أن يعمل مراسلين مختلفين على نفس المقالة. هذا يعني أنه عندما يذهب القراء ويقرأون مقالًا ، فإنهم لن يروا سوى مؤلف واحد في المقالة.
على سبيل المثال: مقال بقلم محمد، مقالة بقلم علي، مقالة بقلم إياد. لا يمكنك الحصول على مقال بواسطة محمد & علي لأن المدير لا يريد مؤلفين أو أكثر للعمل على نفس المقالة.
كيف يمكننا حل هذه "المشكلة" بمساعدة django؟ مفتاح حل هذه المشكلة هو django ForeignKey.
فيما يلي الكود الكامل الذي يمكن استخدامه لتنفيذ فكرة رئيسنا.
from django.db import models # أنشئ النموذج أولاً هنا class Reporter(models.Model): first_name = models.CharField(max_length=30) def __unicode__(self): return self.first_name class Article(models.Model): title = models.CharField(max_length=100) reporter = models.ForeignKey(Reporter) def __unicode__(self): return self.title الآن:
# يُستخدم لتحديد العلاقات بين شخص وآخر django ForeignKey يوضح لنا هذا المثال العملي التالي أن #لإنشاء علاقات واحد لواحد OneToOneField بينما # إنشاء Reporter object R1 from thepub.models import Reporter, Article R1 = Reporter(first_name='Ali') R1.save() # إنشاء Article object A1. A1 = Article.objects.create(title='TDD In Django', reporter=R1) A1.save() # الحصول على اسم الناشر A1.reporter.first_name 'Ali' # إنشاء آخر R2 = Reporter.objects.create(first_name='Mohamed') R2.save() # الآن حاول إضافته للمقالة السابقة A1.reporter.add(R2) # AttributeError سنحصل على خطأ # كما ترى ، لا يمكن ربط كائن مقال بأكثر من كائن ريبورتير واحد. #r1 الآن لنجرب إرفاق أكثر من مقال ل A2 = Article.objects.create(title='Python News', reporter=R1) R1.article_set.all() # [<Article: Python News>, <Article: TDD In Django>]  

يمكنك حفظها يالشكل التالي (هذه الطريقة تخزنها كملف ثنائي وبالتالي غير صالحة للقراءة مباشرةً من الملف):
# نحدد المسار #w ونحدد له وضع الكتابة #b نحدد له صيغة الملف أنها ثنائية with open('/trainHistoryDict', 'wb') as f: pickle.dump(history.history, f) # حفظها أو:
# save to json: hist_json_file = 'history.json' with open(hist_json_file, mode='w') as f: hist_df.to_json(f) أما في حال أنك تريد تخزينها وقراءتها من الملف لاحقاً، قم بتحويلها لقاموس وخزنها كملف csv:
import pandas as pd # بفرض قمت بالتدريب وتخزين النتائج history = model.fit(x_train, y_train, epochs=10) # نحولها لداتافريم hist_df = pd.DataFrame(history.history) # save to csv: hist_csv_file = 'history.csv' with open(hist_csv_file, mode='w') as f: hist_df.to_csv(f)

حسناً سأبدأ بتوضيح فكرة بسيطة (يمكنك تجاوزها إذا لم تكن مهتماً بالتفاصيل). ملفات تنسرفلو تتكون من ملفين رئيسيين هما "Meta graph" و "Checkpoint file" بحيث أن الأول هو عبارة عن بروتوكول ال "buffer" الذي يقوم بحفظ كامل الغراف Graph (أي جميع المتغيرات والعمليات ..إلخ) وهذا الملف يكون بامتداد meta. أما الثاني فهو ملف ثنائي يحتوي على جميع قيم الأوزان وال bias والتدرجات "gradients" وجميع المتغيرات الأخرى المحفوظة. ويكون ملف واحد بامتداد ckpt في الأصدارات التي تسبق الإصدار 0.11 أما في الإصدارات الأحدث فيتم تخزين هذه المعلومات في ملفين:
mymodel.data-00000-of-00001 # هذا هو الملف الذي يحوي متغيرات التدريب mymodel.index وإلى جانب هذه الملفات يحتفظ تنسرفلو بملف آخر هو checkpoint يحتفظ بآخر نقاط  ال checkpoints التي تم حفظها. أي في حالة النسخ الأقدم يتم تخزين النموذج كالتالي:
inception_v1.meta inception_v1.ckpt checkpoint أما الأحدث:
mymodel.data-00000-of-00001 mymodel.index inception_v1.meta checkpoint الآن سنبدأ (يمكنك تخطي القسم السابق). أول خطوة ستقوم بها هي أخذ كائن من الكلاس Saver، ويجب أن تقوم بإنشائه داخل الجلسة التي قمت بتعريف نموذجك ومتغيراتك بها لأن المتغيرات والعمليات ووو تكون نشطة (أو موجودة أو حية .. أيَاً يكن التعبير) فقط ضمن الجسلة الخاصة بها:
saver = tf.train.Saver() saver.save(sess, 'mymodel') # الوسيط الأول هو اسم الجلسة والثاني اسم الملف الذي نريد حفظه فيه مثال:
import tensorflow as tf # على سبيل المثال w1 = tf.Variable(tf.random_normal(shape=[2]), name='w1') w2 = tf.Variable(tf.random_normal(shape=[5]), name='w2') save_ = tf.train.Saver() mysess = tf.Session() sess.run(tf.global_variables_initializer()) save_.save(mysess, 'mymodel') إذا أردنا حفظ النموذج بعد 1000 تكرار، فسنقوم باستدعاء Save وتمرير عدد الخطوات أيضاً :
save_.save(mysess, 'mymodel',global_step=1000) إذا أردت أن يتم حفظ النموذج أيضاً بعد كل 3 ساعات مثلاً، ولمرتين فقط يمكنك القيام بالتالي:
save_ = tf.train.Saver(max_to_keep=2, keep_checkpoint_every_n_hours=3) #max_to_keep نحدد العدد الأعظمي لعمليات الحفظ # keep_checkpoint_every_n_hours الساعات أيضاً يجب أن تعلم أنه عندما لانقوم بتحديد أي وسيط للكلاس Saver  فهذا يعني أننا نريد حفظ كل المتغيرات، وبالتالي إذا أردنا تحديد مايتم حفظه يجب أن نمرره لباني الصف كقائمة أو قاموس:
import tensorflow as tf w1 = tf.Variable(tf.random_normal(shape=[2]), name='w1') w2 = tf.Variable(tf.random_normal(shape=[5]), name='w2') # نمرر له مانريد حفظه فقط save_ = tf.train.Saver([w1,w2]) mysess = tf.Session() mysess.run(tf.global_variables_initializer()) save_.save(mysess, 'mymodel') يمكنك إنشاء الشبكة عن طريق كتابة كود بيثون لإنشاء كل طبقة يدوياً كنموذج أصلي. ومع ذلك، إذا فكرت في الأمر، فقد حفظنا الشبكة في ملف meta. والذي يمكننا استخدامه لإعادة إنشاء الشبكة باستخدام:
save_ = tf.train.import_meta_graph('mymodel.meta') تذكر أن import_meta_graph تلحق الشبكة المحددة في ملف meta بالغراف الحالي. لذلك، سيؤدي هذا إلى إنشاء الغراف / الشبكة لك ولكننا ما زلنا بحاجة إلى تحميل قيم الأوزان التي دربناها على هذا الغراف. ويمكننا استعادتها بالشكل التالي:
with tf.Session() as mysess: new_save_ = tf.train.import_meta_graph(.....meta') new_save_.restore(sess, tf.train.latest_checkpoint('./')) تذكر أيضاً أنها لا يتم حفظ ال placeholders.
 
 

إليك المثال التالي من التوثيق الرسمي:
from django.db import models from django.contrib.auth.models import ( BaseUserManager, AbstractBaseUser ) class MyUserManager(BaseUserManager): def create_user(self, email, date_of_birth, password=None): # ينشئ ويحفظ مستخدمًا بالبريد الإلكتروني المحدد وتاريخ الميلاد وكلمة المرور if not email: raise ValueError('Users must have an email address') user = self.model( email=MyUserManager.normalize_email(email), date_of_birth=date_of_birth, ) user.set_password(password) user.save(using=self._db) return user def create_superuser(self, username, date_of_birth, password): #مع البريد الإلكتروني المحدد وتاريخ الميلاد وكلمة المرور superuser يقوم بحفظ وإنشاء u = self.create_user(username, password=password, date_of_birth=date_of_birth ) u.is_admin = True u.save(using=self._db) return u class MyUser(AbstractBaseUser): email = models.EmailField( verbose_name='email address', max_length=255, unique=True, ) date_of_birth = models.DateField() is_active = models.BooleanField(default=True) is_admin = models.BooleanField(default=False) objects = MyUserManager() USERNAME_FIELD = 'email' REQUIRED_FIELDS = ['date_of_birth'] def get_full_name(self): # يتم التعرف على المستخدم من خلال عنوان بريده الإلكتروني return self.email def get_short_name(self): # يتم التعرف على المستخدم من خلال عنوان بريده الإلكتروني return self.email def __unicode__(self): return self.email def has_perm(self, perm, obj=None): "هل المستخدم لديه سماحية محددة؟" # أبسط إجابة ممكنة: نعم ، دائمًا return True def has_module_perms(self, app_label): "هل يمتلك المستخدم أذونات لعرض التطبيق" app_label "؟" # أبسط إجابة ممكنة: نعم ، دائمًا return True @property def is_staff(self): "هل المستخدم عضو في فريق العمل؟" # أبسط إجابة ممكنة: جميع المسؤولين هم موظفين return self.is_admin كل ما عليك فعله هو إضافة AUTH_USER_MODEL إلى الإعدادات مع المسار إلى كلاس ال custom user ، والتي تتوسع إما AbstractBaseUser (إصدار أكثر قابلية للتخصيص) أو AbstractUser (يمكنك توسيع فئة المستخدم القديمة بشكل أكبر أو أقل).

يشير global_step إلى عدد الباتشات "batches " التي يراها ال Graph .
كما نعلم أنه في الشبكات العصبية يتم إدخال البيانات كحزم batches للشبكة (تغذيتها بالبيانات) ثم يتم تنفيذ عملية forward ثم backward propagation بحيث يتم في هذه المرحلة تحديث قيم الأوزان بشكل يؤدي إلى تقليل ال loss أو ال cost. إن مهمة global_step هي تتبع عدد الحزم batches  التي شاهدها الغراف حتى الآن. وكلما تم تمريره في قائمة وسيطات minimize ، يتم زيادة المتغير بمقدار واحد. و القيمة 0 هنا تشير إلى القيمة الابتدائية لل global_step .

يمكنك القيام بذلك بالشكل التالي من خلال استخدام الدالة map والدالة concat التي تقوم بعملية الربط بين الجداول:
import glob import os import pandas as pd df = pd.concat(map(pd.read_csv, glob.glob(os.path.join('', "my_files*.csv")))) ومن الأفضل تحديد المسار من خلال os.path.join. أو بالشكل التالي بدون استخدام map:
path = r'C:\DRO\DCL_rawdata_files' # قراءة كل الملفات all_files = glob.glob(os.path.join(path, "*.csv")) #Dataframes يحوي كل ال tuple إنشاء df_from_each_file = (pd.read_csv(f) for f in all_files) #concat الآن ربطهما من خلال الدالة concatenated_df = pd.concat(df_from_each_file, ignore_index=True) كما يمكنك استخدام Dask حيث يمكنها قراءة الداتافريم من عدة ملفات:
import dask.dataframe as read df = read.read_csv('data*.csv')  

من أجل القيام بتهيئة Xavier في تنسرفلو، عليك القيام بالتالي:
initialization = tf.initializers.GlorotUniform() v = tf.Variable(initialization(shape=shape)) v = tf.Variable(tf.initializers.GlorotUniform()(shape=shape)) حيث أن كل من Glorot uniform و Xavier uniform هما اسمان مختلفان من لنفس نوع التهيئة. أو بالشكل التالي، لكن يجب أن تعلم أنه بدءاً من تنسرفلو 2.0 ، تم إهمال كل من *.tf.contrib و tf.get_variable:
W = tf.get_variable("W", shape=shape, initializer=tf.contrib.layers.xavier_initializer()) لذا اعتمد على الطريقة الأولى إذا كنت تستخدم إصدار حديث من تنسرفلو.

بشكل عام مع آدم ليس بالضرورة استخدام مفهوم ال learning rate decay لأن آدم يقوم بعملية optimization لل learning rate بشكل تلقائي "هذا ماتقوله المراجع". حيث يقوم ADAM بتحديث أي parameter  بمعدل تعلم فردي "individual learning rate". هذا يعني أن كل parameter في الشبكة له معدل تعلم محدد مرتبط به.  ولكن يتم حساب معدل التعلم الفردي لكل parameter  باستخدام lambda (معدل التعلم الأولي أو الابتدائي)  كحد أعلى. هذا يعني أن كل معدل تعلم فردي يمكن أن يختلف من 0 (بدون تحديث) إلى لامدا (الحد الأقصى لعملية التحديث). وبالرغم من أن معدلات التعلم تتكيف مع نفسها أثناء خطوات التدريب ، ولكن إذا كنت تريد التأكد من أن كل خطوة تحديث لا تتجاوز قيمة لامدا ، فيمكنك استخدام قيمة لامدا المنخفضة باستخدام exponential decay  أو أي خوارزمية تخفيض أخرى. وهذا يمكن أن يساعد في تقليل التكلفة loss خلال الخطوة الأخيرة من التدريب، وذلك عندما تتوقف ال loss التي تم حسابها من خلال معلمة لامدا المرتبطة بها عن الانخفاض.

في حالة النماذج من الشكل One-to-one يكون لدينا دخل واحد و خرج واحد ولايكون هناك معالجة للتسلسلات لذا يمكنك استخدام طبقة fully-connected أي Dense layer:
# One-to-one mymodel.add(Dense(number_of_cells, input_shape=your_input_shape)) أما في حالة many to many فهنا يكون لدينا حالتين إما أن يكون عدد المخرجات = عدد المدخلات وهذا من السهل القيام به كما في المثال في الأسفل:
# Many-to-many model = Sequential() model.add(LSTM(1, input_shape=(timesteps, dim), return_sequences=True)) أو أن يكون عدد المخرجات لايساوي عدد المدخلات وهذا صعب جداً القيام به من خلال كيراس، مثلاً:
model = Sequential() model.add(LSTM(1, input_shape=(timesteps, data_dim), return_sequences=True)) model.add(Lambda(lambda x: x[:, -N:, :])) #هو عدد الخطوات الأخيرة التي تريد تغطيتها N حيث أن أما Many-to-one فهو عندما يكون لدينا عدة مدخلات وخرج واحد لها مثال:
# Many-to-one model = Sequential() model.add(LSTM(1, input_shape=(timesteps,dim))) أما one-to-many فيكون لدينا دخل واحد فقط وعدة مخرجات له، وهي حالة غير مدعومة جيداً في كيراس:
# One-to-many mymodel.add(RepeatVector(number_of_times, input_shape=your_input_shape)) mymodel.add(LSTM(number_of_headen_state, return_sequences=True))  

بشكل مشابه تماماً ل SQL، انظر للمثال التالي:
# Import pandas package import pandas as pd data1 = { 'name':["Tom", "Sara", "Eva","Jack","Laura"], 'age':[14, 51, 6,88,20] } df1 = pd.DataFrame(data1) data2 = { 'name':["Tom", "Paul", "Eva","Jack","Michelle"], 'gender':["M", "M","F","M","F"] } df2 = pd.DataFrame(data2) # طباعته print("Original DataFrame1:\n", df1) print("Original DataFrame2:\n", df2) """ Original DataFrame1: name age 0 Tom 14 1 Sara 51 2 Eva 6 3 Jack 88 4 Laura 20 Original DataFrame2: name gender 0 Tom M 1 Paul M 2 Eva F 3 Jack M 4 Michelle F """ الآن نريد القيام بعملية دمج. نحن لدينا 4 أنواع من الدمج وهي: Inner Join ويمثل تقاطع الجدولين:
# الدمج الداخلي # on تمثل العمود الذي نريد الدمج على أساسه pd.merge(df1,df2, how="inner",on='name') """ name age gender 0 Tom 14 M 1 Eva 6 F 2 Jack 88 M """ لاحظ أنه أعطانا تقاطع الجدولين، أي الأسماء الموجودة في كل من الجدولين + التي ليس لها قيم null.
الآن الدمج الخارجي:
# الدمج الخارجي pd.merge(df1,df2, how="outer",on='name') """ name age gender 0 Tom 14.0 M 1 Sara 51.0 NaN 2 Eva 6.0 F 3 Jack 88.0 M 4 Laura 20.0 NaN 5 Paul NaN M 6 MichelleNaN F """ لاحظ أنه قام بدمج العناصر المشتركة وغير المشتركة في الجدولين. على أساس العمود name. (ربما تلائم ماتحتاجه أكثر)
الآن الدمج اليساري (ماتقوم به هو دمج يساري):
# الدمج الخارجي pd.merge(df1,df2, how="left",on='name') """ name age gender 0 Tom 14 M 1 Sara 51 NaN 2 Eva 6 F 3 Jack 88 M 4 Laura 20 NaN """ يقوم هنا بدمج الجدولين على أساس العمود nameالموجود في الجدول اليساري أي df1.
الآن الدمج اليميني:
frames = [df1, df2] pd.merge(df1,df2, how="right",on='name') """ name age gender 0 Tom 14.0 M 1 Paul NaN M 2 Eva 6.0 F 3 Jack 88.0 M 4 Michelle NaN F """ نفس الفكرة السابقة لكن على أساس العمود name في الجدول اليميني.

هناك العديد من الطرق وإليك إياها:
############# JSON format حفظه ك ############# # حفظ النموذج model_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) # HDF حفظ الأوزان كملف model.save_weights("model.h5") print("Saved model to disk") ############### لتحميله لاحقاً ############# json_file = open('model.json', 'r') loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) # تحميل الأوزان إلى النموذج loaded_model.load_weights("model.h5") أو:
############ YAML Format ############## # pip install PyYAML model_yaml = model.to_yaml() with open("model.yaml", "w") as yaml_file: yaml_file.write(model_yaml) # weights to HDF5 model.save_weights("model.h5") # تحميله لاحقاً yaml_file = open('model.yaml', 'r') loaded_model_yaml = yaml_file.read() yaml_file.close() loaded_model = model_from_yaml(loaded_model_yaml) # تحميل الأوزان إلى النموذج loaded_model.load_weights("model.h5") أو بشكل مباشر من خلال إطار العمل يمكنك حفظ النموذج مع الأوزان وبالنسبة لي هذه هي الطريقة الأفضل والأكثر راحة:
model.save("model.h5") # ولتحميله from tensorflow.keras.models import load_model model = load_model('model.h5')

إليك كل ما قد تحتاجه من معلومات مع المثال التالي:
import tensorflow as tf with tf.compat.v1.Session() as sess: hello = tf.constant('hello world') print(sess.run(hello)) ######################################### # للحصول على كل العقد [n for n in tf.compat.v1.get_default_graph().as_graph_def().node] """ [name: "Const" op: "Const" attr { key: "dtype" value { type: DT_STRING } } attr { key: "value" value { tensor { dtype: DT_STRING tensor_shape { } string_val: "hello world" } } }] """ # oprations للحصول على كل العمليات tf.compat.v1.get_default_graph().get_operations() # [<tf.Operation 'Const' type=Const>] # للحصول على كل المتغيرات tf.compat.v1.global_variables() #Tensors للحصول على كل ال [tensor for op in tf.compat.v1.get_default_graph().get_operations() for tensor in op.values()] # [<tf.Tensor 'Const:0' shape=() dtype=string>] # placeholders الحصول على ال [placeholder for op in tf.compat.v1.get_default_graph().get_operations() if op.type=='Placeholder' for placeholder in op.values()]  

تابع معي.. أول طريقة هي استخدام الدالة apply:
import pandas as pd # هنا فقط تعريف الداتا df = pd.DataFrame({"Fruits": [["Apple", "Oragne"] for i in range(7)]}) print("Given Dataframe is :\n",df) # الآن سنقوم بتطبيق التابع لمدا على كل سطر من البيانات df=df.Fruits.apply(lambda x: pd.Series(" ".join(x).split())) print("\nSplitting Fruits column into two different columns :") # تغيير أسماء الأعمدة بالشمل الذي نريده df.columns=["F1","F@"] print(df) """ Given Dataframe is : Fruits 0 [Apple, Oragne] 1 [Apple, Oragne] 2 [Apple, Oragne] 3 [Apple, Oragne] 4 [Apple, Oragne] 5 [Apple, Oragne] 6 [Apple, Oragne] Splitting Fruits column into two different columns : F1 F@ 0 Apple Oragne 1 Apple Oragne 2 Apple Oragne 3 Apple Oragne 4 Apple Oragne 5 Apple Oragne 6 Apple Oragne """ الفكرة الرئيسية في الكود السابق هو السطر:
df=df.Fruits.apply(lambda x: pd.Series(" ".join(x).split())) كما نعلم فإن Apply يقوم بالمرور على أسطر البيانات سطر سطر ويطبق عليه تابع معين، ونحن استخدمنا التابع lambda الذي يمكننا من كتابة تابع مباشرةً، حيث يقوم هذا التابع بتحويل كل قائمة من الشكل [Apple, Oragne] إلى string من الشكل "Apple Oragne" ثم نقوم بتطبيق دالة split عليها (تقوم هذه الدالة بتحويل السلسلة النصية إللا قائمة بعد أن تقوم بفصل كلمات السلسلة على أساس محرف معين-افتراضياً يتم الفصل على أساس الفراغات-) ثم يتم تحويل القائمة الناتجة إلى pandas.sreies وهذه هي كل الفكرة. للوضوح أكثر:
# هذا مايحدث في كل سطر " ".join(["Apple", "Oragne"]) # "Apple Oragne" "Apple Oragne".split() # ['Apple', 'Oragne'] pd.Series(['Apple', 'Oragne']) """ 0 Apple 1 Oragne dtype: object """ الآن بشكل مشابه قليلاً للطريقة السابقة لكنها تمنحك تحكم أقل في حال كانت المشاكلة أكثر تعقيداً وهي tolist لكنها هنا أسهل:
df=pd.DataFrame(df.Fruits.to_list(),columns = ['F1','F2']) print("\nSplitting Fruits column into two different columns :") print(df) """ Splitting Fruits column into two different columns : F1 F2 0 Apple Oragne 1 Apple Oragne 2 Apple Oragne 3 Apple Oragne 4 Apple Oragne 5 Apple Oragne 6 Apple Oragne """ في الحالة العامة أي عندما يكون لدينا نص مركب ونريد وضع كل جزء في عمود كما في المثال التالي، يكفينا استخدام الدالة split مع تحديد المحرف الذي نريد الفصل على أساسه:
import pandas as pd df = pd.DataFrame({'Name': ['Ali Ahmad', 'Eyad Ismael']}) print("Given Dataframe is :\n",df) print("\nSplitting 'Name' column into two different columns :\n") df=df.Name.str.split(expand=True) df.columns=["First","Last"] print(df) """ Given Dataframe is : Name 0 Ali Ahmad 1 Eyad Ismael Splitting 'Name' column into two different columns : First Last 0 Ali Ahmad 1 Eyad Ismael """  

قم بفحص الإصدار الذي لديك من CUDA ومن cuDNN:
# cuDNN grep CUDNN_MAJOR -A 2 /usr/local/cuda/include/cudnn.h # CUDA cat /usr/local/cuda/version.txt ثم قم بتنزيل النسخة التي تتطابق معهم من خلال الرابط التالي الذي يحوي جداول كاملة توفر نظرة عامة على المجموعات المدعومة و المختبرة رسمياً من CUDA و TensorFlow على Linux و macOS و Windows:
https://www.tensorflow.org/install/source#tested_build_configurations
ملاحظة : هذه الجداول يتم تحديثها باستمرار. إليك عينة من هذه الجداول للتركيبات المتوافقة على ال GPU في ويندوز 10:

يجب أن تضيف إلى الأمر الذي تريد تنفيذه سماحية المستخدم "user permission" وهذا مايخبرك به الخطأ أي أضف --user كالتالي:
pip3 install --upgrade tensorflow-gpu --user

يمكنك القيام بذلك كالتالي: أولاً إنشاء " custom management command " ، على سبيل المثال:
python manage.py my_cool_command واستخدم cron على Linux أو at  على Windows لتشغيل الأمر الخاص بك في الوقت الذي تحتاجه.ويعمل حل cron بشكل جيد جداً مع التطبيقات الصغيرة والمتوسطة الحجم وحيث لا تريد الكثير من التبعيات الخارجية. وهو حل بسيط لا يتطلب تثبيت مكدس AMQP. أيضاً يمكنك استخدام Celery وهو عبارة عن قائمة انتظار مهام موزعة ، مبنية على AMQP (RabbitMQ). كما أنه يتعامل مع المهام الدورية بطريقة تشبه كرون. ومن السهل جداً إعداد Celery باستخدام django ، وستتخطى المهام الدورية فعلياً المهام الفائتة في حالة حدوث تعطل. يحتوي Celery أيضاً على آليات إعادة المحاولة المضمنة، في حالة فشل المهمة.

بدءاً من نسخة تنسرفلو Tensorflow2.0 أصبح التنفيذ الافتراضي في تنسرفلو "Eager Execution" وهو مصطلح يشير إلى عملية تقييم العمليات على الفور، دون الانتظار لتشكيل ال Graph. أي يمكنك معرفة قيمة أي متغير أو ناتج أي عملية على الفور أما في النسخ السابقة لهذه النسخة كان التنفيذ الافتراضي للعمليات في تنسرفلو هو "Graph Execution" أي أن العمليات لايتم تقييمها حتى يتم إنشاء الجلسة بواسطة:
tf.Session().run() أي لانكون قادرين على معرفة قيم المتغيرات حتى يتم تنفيذ ال Graph من أول عقدة فيه لآخر عقدة من خلال هذا الكود.
الآن أنت لديك نسخة 2.4 وتحاول استخدام Session التي لم يعد هناك حاجة لها فهي غير موجودة بعد الآن في تنسرفلو (بدءاً من 2.0). لذا لاداعي لاستخدام session ويمكنك عرض ناتج أي عملية مباشرةً كالتالي:
import tensorflow as tf msg = tf.constant('Hello, TensorFlow!') tf.print(msg) # Hello, TensorFlow! أما إذا كنت تريد أن تستخدم Session واعتماد ال Graph Execution فيمكنك تعطيل Eager Execution من خلال السطر التالي:
tf.compat.v1.disable_eager_execution() وبالتالي يصبح الكود:
import tensorflow as tf tf.compat.v1.disable_eager_execution() hello = tf.constant('Hello, TensorFlow!') sess = tf.compat.v1.Session() print(sess.run(hello)) أو من خلال with:
import tensorflow as tf with tf.compat.v1.Session() as sess: hello = tf.constant('hello world') print(sess.run(hello))

في حال كنت تستخدم tensorflow2.x:
print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU'))) في tensorflow1:
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True)) أو بالشكل التالي حيث يعرض لك قائمة بالأجهزة المتاحة له:
from tensorflow.python.client import device_lib print(device_lib.list_local_devices()) """ [name: "/cpu:0" device_type: "CPU" memory_limit: 268435456 locality { } incarnation: 4402277519343584096, name: "/gpu:0" device_type: "GPU" memory_limit: 6772842168 locality { bus_id: 1 } incarnation: 7471795903849088328 physical_device_desc: "device: 0, name: GeForce GTX 1070, pci bus id: 0000:05:00.0" ] """ أو:
tf.test.is_gpu_available( cuda_only=False, min_cuda_compute_capability=None) حيث يرد True إذا كانت تنسرفلو تستخدم ال GPU.

يمكنك معرفة ماحدث لل object عند وصوله لل template كالتالي:
@register.filter def pdb(element): import pdb; pdb.set_trace() return element الآن ، داخل القالب يمكنك القيام ب {{template_var | pdb}} والدخول إلى جلسة pdb حيث يمكنك فحص عنصرك.
كما يمكنك استخدام PyCharm فهو يجعلك قادراً بصرياً على المرور عبر الكود الخاص بك ومعرفة ما يحدث (يشير لك لأماكن وجود أخطاء في الكود أثناء كتابته). أيضاً هناك epdb وهو إضافة أو توسيع ل Python Debugge :
import epdb; epdb.serve() بمجرد تنفيذ هذا الكود، أفتح "Python interpreter" وأتصل ب serving instance. يمكنك تحليل جميع القيم والخطوات من خلال الكود باستخدام أوامر pdb مثل n ، s ، إلخ.
import epdb; epdb.connect() (Epdb) request <WSGIRequest path:/foo, GET:<QueryDict: {}>, POST:<QuestDict: {}>, ... > (Epdb) request.session.session_key 'i31kq7lljj3up5v7hbw9cff0rga2vlq5' (Epdb) list 85 raise some_error.CustomError() 86 87 # Example login view 88 def login(request, username, password): 89 import epdb; epdb.serve() 90 -> return my_login_method(username, password) 91 92 # Example view to show session key 93 def get_session_key(request): 94 return request.session.session_key 95  

يمكنك القيام بذلك بعدة طرق، أولها استخدام الوسيط device_count عند إنشاء الجلسة كالتالي:
sess = tf.Session( config=tf.ConfigProto( device_count = {'GPU': 0}) # عنه GPU إخفاء ال ) أو من خلال ضبط  قيمة متغير البيئة "environment variable" على  1- أو " ":
import os os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ['CUDA_VISIBLE_DEVICES'] = '-1' أو:
import tensorflow as tf tf.config.set_visible_devices([], 'GPU') حيث أن كل هذه الطرق تعتمد على إخفاء ال GPU عن المترجم وبالتالي يذهب إلى ال CPU.
أو من خلال tf.device مع جملة with حيث نضع كل الكود الذي نريد تنفيذه على ال cpu ضمن البلوك نفسه (أقصد الكتلة نفسها) أي:
with tf.device('/CPU:0'): # ضع الكود هنا ضمن الكتلة