Ali Haidar Ahmad

نستخدم CSVLogger callback  للقيام بحفظ نتائج ال Epochs خلال عملية التدريب:
tf.keras.callbacks.CSVLogger(filename, separator=",", append=False) حيث نمرر له مسار الملف الذي نريد أن يتم حفظ البيانات فيه. والفاصل الذي نريد أن يتم فصل العناصر فيه. أما الوسيط الأخير فنضبطه على True إذا كان الملف موجود مسبقاً ونريد الإضافة عليه (في حالة كان موجود ولم يتم ضبطه على True سيتم الكتابة فوق الملف).  ويمكننا استخدامه أثناء تدريب النماذج بالشكل التالي:
# نقوم بتعريف الكول باكس أولاً csv_logger = CSVLogger('training.log') #fit في الدالة callbacks ثم نمرره إلى الوسيطة model.fit(X_train, Y_train, callbacks=[csv_logger]) مثال:
from tensorflow.keras.models import Sequential from sklearn.datasets import make_moons from tensorflow.keras.layers import Dense # تعريف بيانات عشوائية X, y = make_moons(n_samples=200, noise=0.2, random_state=4) # قسم البيانات إلى تدريب واختبار n_train = 30 trainX, testX = X[:n_train, :], X[n_train:, :] trainy, testy = y[:n_train], y[n_train:] # تعريف نموذج model = Sequential() model.add(Dense(600, input_dim=2, activation='relu')) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # تعريف الكولباكس from tensorflow.keras.callbacks import CSVLogger csv_logger = CSVLogger('training.log') # تدريب النموذدج model.fit(trainX, trainy, validation_data=(testX, testy), epochs=5000, verbose=0, callbacks=[csv_logger])  

نعم يمكنك استخدام الأداة  inspect_checkpoint.py حيث أنها توفر لنا الدالة print_tensors_in_checkpoint_file التي يمكننا من خلالها الحصول على مانريده، ولها الشكل التالي:
print_tensors_in_checkpoint_file(file_name, tensor_name, all_tensors,all_tensor_names) الوسيط الأول هو مسار ملف ال checkpoint. أما بالنسبة للوسيط الثاني فهو اسم التنسر وهنا لدينا حالتان:
حالة لم نمرر أي قيمة لل tensorname (أو مررنا " "): سيتم طباعة أسماء كل التنسر الموجودة مع أبعادها (ال shapes) في ملف ال ckp.
حالة تم تمرير اسم للتنسر: سيتم طباعة محتوى هذه التنسر.
الوسيط الثالث نضعه على True في حال أردنا طباعة كل التنسر (افتراضياً True). أما الوسيط الأخير نضعه على TRue في حال أردنا طباعة أسماء كل التنسر.
مثال:
from tensorflow.python.tools.inspect_checkpoint import print_tensors_in_checkpoint_file import os # تحميل مسار الملف ckp_path = os.path.join(dir, "model_10000.ckpt") # الحصول على أسماء كل التنسر الموجودة print_tensors_in_checkpoint_file(file_name=ckp_path, tensor_name='',all_tensor_names=True) # الخرج يكون بالشكل التالي: # v0/RMSprop (DT_FLOAT) [4,4,1,45] # الآن بفرض أريد الحصول على محتويات المتغير السابق print_tensors_in_checkpoint_file(file_name=checkpoint_path, tensor_name='v0') # tensor_name: v0 [[[[ 5.444958265e-02 2.00026209e-01 .... أو من خلال الطريقة البديلة التالية:
from tensorflow.python import pywrap_tensorflow import os ckp = os.path.join(dir, "model_1000.ckpt") r = pywrap_tensorflow.NewCheckpointReader(ckp) x = r.get_variable_to_shape_map() for tensor in x: print("Tensor name: ", tensor) # الأسماء print(r.get_tensor(tensor)) # القيم

أولاً سأبدأ بالشكل العام لهذه الطبقة:
tf.compat.v1.keras.layers.CuDNNLSTM( units, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', unit_forget_bias=True, kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, return_sequences=False, return_state=False, go_backwards=False, **kwargs ) حيث أن units هي عدد الخلايا أو الوحدات في الشبكة وتمثل عدد المخرجات (output space)، أما الوسيط الثاني فيستخدم من أجل التحويل الخطي للمدخلات وهو عبارة عن مُهيئ لمصفوفة أوزان النواة (افتراضياً نستخدم عادةً glorot_uniform لأغلب  المهام)، أما الثالث فهو مُهيئ لمصفوفة أوزان recurrent_kernel ، وتُستخدم للتحويل الخطي للحالة المتكررة "recurrent state"  والقيمة الافتراضية التي نستخدمها غالباً "orthogonal". أما الوسيط الرابع فهو مُهيئ لمصفوفة الانحراف bias (افتراضياً 0 وأيضاً نستخدم هذه القيمة غالباً أي لاتشغل نفسك بتغييرها).  الوسيط الخامس فيحدد فيما إذا كنت تريد إضافة 1 إلى الانحراف bias الخاص ببوابة النسيان (يستحسن استخدامه حسب ماذكره Jozefowicz et al.). الوسيط السادس فيستخدم لتطبيق penalties على أوزان الطبقة (أي على ال Kernal_weights). السابع أيضاً مثل السادس لكن هنا يتم تطبيقها على ال recurrent_kernel. الثامن كذلك الأمر لكنه يطبق على أوزان ال bias  أي على ال (bias vector). الوسيط التاسع return_sequences لتحديد شكل الإخراج ففي حال قمت بضبطه على True سوف يكون الخرج 3D حيث يقوم بإعادة كامل التسلسل أما في الحالة الافتراضية أي False يقوم بإعادة الخرج الأخير من تسلسل الخرج. طبعاً لكي لاتقع في الأخطاء يجب أن نضع True إذا كانت الطبقة التالية هي طبقة تكرارية و False إذا كانت طبقة Dense فالطبقات التكرارية دخلها يجب أن يكون 3D بينما طبقات Dense دخلها يكون 2D. والدخل لهذه الطبقة يكون: [batch, timesteps, feature] والخرج: يكون إما 2D أو 3D كما أشرنا. أما الوسيط العاشر فهو لتحديد فيما إذا كنت ترد إرجاع الحالة "state" الأخيرة أم لا إلى جانب الخرج. الحادي عشر في حالة ضبطه على True فسيتم معالجة تسلسل الدخال بشكل عكسي وسيرجع التسلسل المعكوس.
الآن هذا كان تعريف بالطبقة في حالة أردت استخدامه، ونستخدمه مع النماذج بشكل مشابه للطبقة LSTM (سأرفق رابط تم فيه شرح هذه الطبقة مع مثال). حيث أن هذه الطبقة هي نفسها الطبقة LSTM ولكن مع بعض التحديثات+أسرع. فالطبقة CuDNNLSTM نسميها "Fast LSTM" ولايمكنك تشغيلها إلا على ال GPU ومع TensorFlow (لايمكنك استخدامها من إطار العمل keras فهي غير معرفة هناك) هذه الطبقة أسرع بحوالي 10 مرات من طبقة LSTM العادية. وسميت بهذا الاسم لأنه تم بناءها للاستفادة من النواة cuDNN وهي اختصار ل CUDA Deep Neural Network (cuDNN).
 

تقدم لك كيراس Keras و tensorflow.keras الكلاس ExponentialDecay لتطبيق تقنية Exponential Learning Rate Decay ولها الشكل التالي:
tf.keras.optimizers.schedules.ExponentialDecay( initial_learning_rate, decay_steps, decay_rate, staircase=False ) حيث أن الوسيط الأول هو قيمة معدل التعلم الابتدائي، أما الوسيط الثاني فهو عدد خطوات ال decay،والوسيط الثالث هو مقدار ال decay ( معامل التغير في قيمة معدل التعلم ويفضل أن تكون قيمته 0.95 ولايجب أن تتجاوز ال 1)، الوسيط الأخير لجعل ناتج القسمة step/decaysteps قيمة صحيحة وبالتالي ستتبع تغيرات قيم معدل التعلم نهجاً سلميَاً.
أما المعادلة التي يتم تطبيقها لحساب ال lr في كل epoch هي:
def decayed_learning_rate(step): return initial_learning_rate * decay_rate ^ (step / decay_steps) ولاستخدامه نقوم بتعريف object من هذا الكلاس ثم تمريره إلى وسيطة learning Rate في أي Optimaizer معرف في إطار العمل. مثال(decay كل 100000 خطوة بأساس 0.96:
# نحدد القيمة الأولية initial_learning_rate = 0.1 # نعرَف غرض lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay( initial_learning_rate, decay_steps=100000, decay_rate=0.96, staircase=True) # نقوم بتمريره للأوبتيمايزر model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=lr_schedule), loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit(data, labels, epochs=5)  

ليكن لدينا المثال التالي:
df """ col1 col2 col3 col4 b ali 33 Up wq c ali 23 we qw a dac 23 we we e gsg 12 we ew f cds 66 ew ds g sdac 95 sdac dc i cd 55 adsc r j das 35 cda r k ads 12 cd vc d ad 88 cda Bhgu """ 1. فرز صفوف داتافريم بناءً على عمود معين:
df.sort_values(by = 'col1') """ col1 col2 col3 col4 d ad 88 cda Bhgu k ads 12 cd vc b ali 33 Up wq c ali 23 we qw i cd 55 adsc r f cds 66 ew ds a dac 23 we we j das 35 cda r e gsg 12 we ew g sdac 95 sdac dc """ 2. اعتماداً على عدة أعمدة:
df.sort_values(by = ['Name', 'Age']) 3. فرز الصفوف بناءً على عمود معين وترتيب تنازلي:
df.sort_values(by = 'col', ascending = False) 4. لجعل عملية الفرز تتم على البيانات الأصلية نستخدم inplace:
df.sort_values(by = 'Name', inplace = True) ليكن لدينا مثال آخر:
Arabic Math Science English Ankit 75 50 60 70 Rahul 75 55 65 75 Aishwarya 75 35 45 25 Shivangi 75 90 60 70 Priya 76 90 70 60 Swapnil 90 80 70 60 Shaurya 65 10 30 20 1. فرز الأعمدة بناءً على سطر محدد:
df.sort_values(by = 'Priya', axis = 1) """ English Science Arabic Math Ankit 70 60 75 50 Rahul 75 65 75 55 Aishwarya 25 45 75 35 Shivangi 70 60 75 90 Priya 60 70 76 90 Swapnil 60 70 90 80 Shaurya 20 30 65 10 """ وأخيراً يمكنك اختيار خوارزمية البحث التي تريدها من خلال الوسيط kind وهذه هي الخيارات المتوفرة:
{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, default ‘quicksort’ لاستخدامها:
DataFrame.sort_values(... ... kind='quicksort' .. . . ) ,ولتطبيق عملية ما قبل أن يطبق الفرز يمكن استخدام الوسيط key وتمرير الدالة المناسبة له.

size و count كل منهما يستخدم من أجل أغراض مختلفة.
size هو attribute تقوم بحساب حجم (أو طول) الكائن الذي تم استدعاؤه عليه. وبطبيعة الحال يتضمن هذا أيضاً الصفوف / القيم التي هي NaN. أما count فهو تابع مهمته عد الخلايا التي ليست NaN لكل عمود أو صف.
import pandas as pd import numpy as np df = pd.DataFrame({'col': ['x', np.nan, 'x']}) df """ col 0 x 1 NaN 2 x """ df.col.size # 3 df.col.count() # 2 nan لم يحسب ال أيضاً هناك اختلاف في بنية الناتج عند استدعاء GroupBy.size و GroupBy.count. حيث أن GroupBy.count تعيد DataFrame أما GroupBy.siz تعيد series:
import pandas as pd import numpy as np df = pd.DataFrame({ 'gb': list('aaab'), 'col': ['x', np.nan, 'x',"x"]}) df """ gb col 0 a x 1 a NaN 2 a x 3 b x """ df.groupby('gb').size() """ gb a 3 b 1 dtype: int64 """ df.groupby('gb').count() """ col gb a 2 b 1 """ type(df.groupby('gb').count()) # pandas.core.frame.DataFrame type(df.groupby('gb').size()) # pandas.core.series.Series هناك اختلاف أخير عند استخدامنا ل pivot_table. لنفترض أننا نود حساب ال cross tabulation لـلداتافريم التالي:
df """ A B 0 0 1 1 0 1 2 1 2 3 0 2 4 0 0 """ pd.crosstab(df.A, df.B) """ B 0 1 2 A 0 1 2 1 1 0 0 1 """ #يمكنك عرض الحجم pivot_table باستخدام df.pivot_table(index='A', columns='B', aggfunc='size', fill_value=0) """ B 0 1 2 A 0 1 2 1 1 0 0 1 """ #لايعمل هنا حيث يتم إرجاع داتافريم فارغ count لكن df.pivot_table(index='A', columns='B', aggfunc='count') """ Empty DataFrame Columns: [] Index: [0, 1] """  

الكلام التالي ينطبق على عدد الوحدات في بقية أنواع الطبقات أيضاً مثل Dense وغيرها في كيراس وتنسرفلو..
num_units هو عدد يشير إلى ال "Learning capacity" أي قدرة الشبكة على التعلم وهي تعكس عدد ال "learned parameters" ضمن الطبقة أي عدد المعلمات التي سيتم تدريبها لمعالجة بياناتك. إن num_units يندرج تحت مفهوم ال Hyperparameters أي المعاملات العليا للنموذج، أي يجب أن تقوم بضبطها من خلال التجريب، أي ليس هناك قاعدة ثابتة لاختيار قيمتها لكن هناك نقاط يجب وضعها بعين الاعتبار عند تحديد قيمتها وهي:
زيادة عددها يعطي الشبكة قدرة أكبر على التعلم من نماذج بيانات أكبر و أكثر تعقيداً (تعطي النموذج قدرة أكبر على التعلم من البيانات-يمكنك تخيل الأمر على أنه حجم ذاكرتها فكلما زاد حجمها زادت قدرتها على التعلم-). لكن زيادة عددها قد يجعل النموذج يتجه إلى حالة ال Oveffitting لذا يجب أن تكون حذراً وأن لتجعل حجمها يتناسب مع حجم المشكلة (عدد ال features للعينات وعدد العينات أي حجم الداتاسيت بشكل عام ومدى تعقيدها). تقليل عددها يجعل الشبكة أضعف وأقل قدرة على التعلم من البيانات. وبالتالي قد يتجه النموذج إلى حالة Underfitting. لذا يجب الموازنة بين الأمرين السابقين أي عملية Trade-off بينهما.  أما بالنسبة للعدد 128 فهذا ليس رقماً ثابتاً كما أوضحت لك هو Hyperparameter لكن في كثير من الأحيان يكون ملائم. كما تجدر الإشارة إلى أن عدد ال num_units يفضل دوماً أن يتم أخذه من العلاقة 2 أس n أي: 16- 32-64-128-256-512.... لأن هذه الأرقام تسرع عمليات الحساب لأن المعالج يفضلها.
 

يمكن تحقيق ذلك عن طريق إنشاء  محسِّنَيْن "GradientDescentOptimizer". لنفرض أن لديك شبكة مسبقة التدريب من 5 طبقات ونريد ضبط معدل التعلم لأول لهم على 0.00001 ونريد طبقة إضافية بمعدل 0.0001 .  في هذه الحالة يمكنك استخدام tf.trainable_variables للحصول على جميع متغيرات التدريب وتقرر الاختيار من بينها. كالتالي:
var_list1 = [variables from first 5 layers] var_list2 = [the rest of variables] opt1 = tf.train.GradientDescentOptimizer(0.00001) opt2 = tf.train.GradientDescentOptimizer(0.0001) grads = tf.gradients(loss, var_list1 + var_list2) grads1 = grads[:len(var_list1)] grads2 = grads[len(var_list1):] tran_op1 = opt1.apply_gradients(zip(grads1, var_list1)) train_op2 = opt2.apply_gradients(zip(grads2, var_list2)) train_op = tf.group(train_op1, train_op2)

سأقوم بإنشاء قالب للقيام بذلك:
import numpy as np import tensorflow.train.string_input_producer as qu import tensorflow.train.start_queue_runners as sqr import tensorflow as tf # قائمة بالملفات التي سنقرأها queue = qu(['tf.png']) # قراءة الملفات _, v = tf.WholeFileReader().read(queue) #حسب نوع الصور التي لديك decode_jpeg أو decode_png استخدم image = tf.image.decode_png(v) initialize = tf.initialize_all_variables() with tf.Session() as sess: sess.run(initialize) # ملء قائمة انتظار اسم الملف c = tf.train.Coordinator() threads = sqr(coord=c) for i in range(1): # طول القائمة التي لدينا image = image.eval() # الصورة ك تنسر # طباعة أبعادها image.shape # عرضها Image.show(Image.fromarray(np.asarray(image))) coord.request_stop() coord.join(threads) الكود السابق يقوم فقط بتحميل الصورة كتنسر والآن لحفظها ضمن ملف TFRecords:
def _int64_feature(value): return tf.train.Feature(int64_list=tf.train.Int64List(value=[value])) def _bytes_feature(value): return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value])) # مجموعة الصور والتسميات كمدخلات def convert_to(images, labels, name): num_examples = labels.shape[0] if images.shape[0] != num_examples: raise ValueError("Images size %d does not match label size %d." % (images.shape[0], num_examples)) rows = images.shape[1] cols = images.shape[2] depth = images.shape[3] filename = os.path.join(FLAGS.directory, name + '.tfrecords') print('Writing', filename) writer = tf.python_io.TFRecordWriter(filename) for index in range(num_examples): image_raw = images[index].tostring() example = tf.train.Example(features=tf.train.Features(feature={ 'height': _int64_feature(rows), 'width': _int64_feature(cols), 'depth': _int64_feature(depth), 'label': _int64_feature(int(labels[index])), 'image_raw': _bytes_feature(image_raw)})) writer.write(example.SerializeToString()) ثم لقراءتها لاحقاً:
#"train.TFRecord" لاتنسى إنشاء قائمة انتظار لاسم الملف لمسار ملف # القيمة المعادة لهذا التابع هو بياناتك بعد قراءتها #label أي الصورة وال def read_and_decode(filename_queue): reader = tf.TFRecordReader() _, serialized_example = reader.read(filename_queue) features = tf.parse_single_example( serialized_example, dense_keys=['image_raw', 'label'], # لم يتم تحديد الإعدادات الافتراضية لأن كلا المفتاحين مطلوبان dense_types=[tf.string, tf.int64]) image = tf.decode_raw(features['image_raw'], tf.uint8) image = tf.reshape(image, [my_cifar.n_input]) image.set_shape([my_cifar.n_input]) # إذا أردت يمكنك هنا أن تقوم بإعادة تعيين أبعاد الصور لديك أو تطبيق بعض العمليات على الصورة # الآن سنقوم بتحويل الصورة لفكتور # Convert from [0, 255] -> [-0.5, 0.5] floats. image = tf.cast(image, tf.float32) image = tf.cast(image, tf.float32) * (1. / 255) - 0.5 #int32 إلى uint8 التحويل من label = tf.cast(features['label'], tf.int32) return image, label

بفرض لدي التنسر التالية:
ten = tf.constant([[0.0, 0.0], [0.0, 0.0]]) #[0,0] ونريد تعديل الخلية idx = [[0, 0]] # قائمة بالمواقع المراد تحديث قيمها # القيمة المراد إضافتها val = [3.0] # أبعاد المصفوفة dim = [2, 2] k = tf.SparseTensor(idx, val, dim) ثم نستخدم العملية tf.sparse_tensor_to_dense  لإنشاء dense tenso من k  ثم إضافتها ل ten:
out = ten + tf.sparse_tensor_to_dense(k) sess = tf.Session() sess.run(out) # ==> array([[ 3., 0.], # [ 0., 0.]], dtype=float32)

حسناً لنبدأ بتوضيح تنسيق TFRecord : هو تنسيق بسيط لتخزين سلسلة من السجلات الثنائية. مخازن البروتوكول هي مكتبة عبر الأنظمة الأساسية ومتعددة اللغات لتسلسل فعال للبيانات المنظمة. يتم تعريف رسائل البروتوكول بواسطة ملفات .proto ، وهي غالباً أسهل طريقة لفهم نوع الرسالة.
الرسالة tf.train.Example (أو protobuf) هي نوع رسالة مرن يمثل تعيين {"string": value} . إنه مصمم للاستخدام مع TensorFlow ويتم استخدامه في جميع واجهات برمجة التطبيقات عالية المستوى مثل TFX .
بشكل عام ، يجب أن تقوم بتقسيم بياناتك عبر ملفات متعددة حتى تتمكن من موازنة الإدخال / الإخراج (داخل مضيف واحد أو عبر مضيفين متعددين). القاعدة الأساسية هي أن يكون لديك ما لا يقل عن 10 أضعاف عدد الملفات التي سيكون هناك مضيفون يقرؤون البيانات. وفي الوقت نفسه ، يجب أن يكون كل ملف كبيراً بدرجة كافية (10 ميجا بايت على الأقل و 100 ميجا بايت على الأقل) حتى تتمكن من الاستفادة من الجلب المسبق للإدخال / الإخراج. على سبيل المثال ، لنفترض أن لديك X جيجابايت من البيانات وأنك تخطط للتدريب على ما يصل إلى N مضيفين. من الناحية المثالية ، يجب أن تقوم بتقسيم البيانات إلى ~ 10*N الملفات ، طالما أن ~ X/(10*N) هي 10 ميجا بايت + (وبشكل مثالي 100 ميجا بايت +). إذا كان أقل من ذلك ، فقد تحتاج إلى إنشاء عدد أقل من الأجزاء لمقايضة مزايا التوازي ومزايا الجلب المسبق للإدخال / الإخراج.
الآن لقراءة ملف TFRecord :
يمكن تحليل الموترات التي تمت سلسلتها "serialized tensors"  باستخدام tf.train.Example.ParseFromString:
filenames = [filename] raw_dataset = tf.data.TFRecordDataset(filenames) raw_dataset # <TFRecordDatasetV2 shapes: (), types: tf.string> for raw_record in raw_dataset.take(1): example = tf.train.Example() example.ParseFromString(raw_record.numpy()) print(example) """ features { feature { key: "feature0" value { int64_list { value: 1 } } } feature { key: "feature1" value { int64_list { value: 1 } } } feature { key: "feature2" value { bytes_list { value: "dog" } } } feature { key: "feature3" value { float_list { value: -0.9885607957839966 } } } } """ كما يمكنك قراءتها من خلال tf_record_iterator مثلاً:
import tensorflow.python_io.tf_record_iterator as record import tensorflow as tf for sample in record("file.tfrecord"): output = tf.train.SequenceExample.FromString(sample) break # أزلها لعرض كل العينات output #وإلا سيُظهر لك محتوى العينة الأولى # لفحص الميزات "الفيتشرز" الفردية باستخدام مفاتيحها output.context.feature["key"] #feature_lists من أجل output.feature_lists.feature_list["key"]  

WebSocket هو بروتوكول الاتصال الذي يوفر اتصالاً ثنائي الاتجاه بين العميل والخادم عبر TCP. يظل WebSocket مفتوحاً طوال الوقت، لذا فهو يسمح بنقل البيانات في الوقت الفعلي (real time). عندما يقوم العملاء بإرسال الطلب إلى الخادم، فإنه لا يغلق الاتصال عند تلقي الاستجابة، بل يستمر وينتظر العميل أو الخادم لإنهاء الطلب.
ميزاته:
يساعد WebSocket في الاتصال في الوقت الفعلي بين العميل وخادم الويب. يساعد هذا البروتوكول في التحول إلى cross-platform في عالم ال real-time بين الخادم والعميل. يتيح أيضاً للأعمال التجارية في جميع أنحاء العالم الحصول على تطبيق ويب في الوقت الفعلي لتعزيز وزيادة الجدوى. الميزة الرئيسية أنه يعتمد على اتصال HTTP حيث أنه يوفر اتصال مزدوج الاتجاه. إليك مخطط له:

لماذا نحتاجه:
يوفر اتصالًا ثنائي الاتجاه ، مما يساعد في استمرار الاتصال الذي تم إنشاؤه بين العميل وخادم الويب. كما أنه يفي بالمعايير ويوفر الدقة والكفاءة في أحداث التدفق (من وإلى) مع زمن انتقال ضئيل negligible latency. WebSocket يزيل الحمل ويقلل من التعقيد. يجعل الاتصال في الوقت الفعلي سهل وفعال. Socket.IO هي مكتبة تتيح الاتصال في الوقت الفعلي مع نمط اتصال full-duplex  بين العميل وخوادم الويب. ويستخدم بروتوكول WebSocket لتوفير الواجهة. وكلاً من WebSocket vs Socket.io هما مكتبات تعتمد على الأحداث (مقادة بال event).
من جانب العميل: هي المكتبة التي تعمل داخل المتصفح. من جانب الخادم: مكتبة Node.js. ميزاته:
يساعد في البث إلى مآخذ متعددة في وقت واحد ويتعامل مع الاتصال بشفافية. يعمل على جميع المنصات أو الخادم أو الجهاز ، مما يضمن المساواة والموثوقية والسرعة. يقوم تلقائياً بترقية المتطلبات إلى WebSocket إذا لزم الأمر. هو بروتوكول نقل مخصص في الوقت الفعلي. تنفيذه يكون فوق البروتوكولات الأخرى يتطلب استخدام كلا المكتبتين من جانب العميل بالإضافة إلى مكتبة من جانب الخادم. يعمل IO على الأحداث القائمة على العمل "work-based events". هناك بعض الأحداث المحجوزة التي يمكن الوصول إليها باستخدام Socket على جانب الخادم مثل Connect و message و Disconnect و Ping و Reconnect. هناك بعض الأحداث المحجوزة القائمة على العميل مثل الاتصال وخطأ الاتصال ومهلة الاتصال وإعادة الاتصال وما إلى ذلك. لماذا نحتاجه:
يتعامل مع مستوى الدعم المتنوع "various support level" والتناقضات "inconsistencies" من المتصفح. تتعامل مع التدهورات الناتجة من استخدام البدائل التقنية لتوفر اتصال  full-duplex في الوقت الفعلي. بعض المقارنة بينهم:
WebSocket هو البروتوكول الذي تم إنشاؤه عبر اتصال TCP. بينما Socket هي مكتبة تعمل مع WebSocket. WebSocket يوفر الاتصال عبر TCP ، بينما Socket.io هي مكتبة لتجريد اتصالات WebSocket. لا يحتوي WebSocket على خيارات fallback، بينما يدعمها Socket.io. WebSocket هي التقنية ، بينما Socket.io هي مكتبة لـ WebSocket. WebSocket  لايدعم ال broadcasting بينما Socket يدعمها. Proxy و load balancer غير مدعومين في WebSocket. بينما مدعومين في socket. Socket يوفر الاتصال القائم على الحدث بين المتصفح والخادم. بينما WebSocket يوفر اتصال مزدوج الاتجاه لاتصالات TCP.    

إذا كنت تريد إجراء تحليل خاص فهنا يجب أن تذهب إلى الدالة tf.train.summary_iterator وذلك لمرور (looping) على كل المخازن المؤقتة للبروتوكول tf.Event و tf.Summary في السجل:
for summary in tf.train.summary_iterator("/path/to/log/file"): # نفذ تحليلاتك هنا في تنسرفلو 2 استوردها بالشكل التالي فقد تغير موقعها:
from tensorflow.python.summary.summary_iterator import summary_iterator يمكنك استخدام TensorBoard فهي أداة رائعة توفرها تنسرفلو لعرض البيانات والسجلات (summary logs). لكن

حسب التوثيق "في TensorFlow ، يكون للتنسر shape ستاتيكي (مستدل) وشكل ديناميكي (حقيقي). يمكن معرفة ال shape الستاتيكي باستخدام الدالة  tf.Tensor.get_shape: يُستدل على هذا ال shape من العمليات التي تم استخدامها لإنشاء هذا التنسر، وقد يكون مكتملًا جزئياً. إذا لم يتم تحديد ال shape الستاتيكي بالكامل، فيمكن تحديد الشكل الديناميكي لـ Tensor t من خلال tf.shape (t)." حسناً ربما لم تفهم شيئ. تابع معي..
في بعض الأحيان ، يعتمد شكل التنسر على قيمة يتم حسابها في زمن التنفيذ. لنأخذ المثال التالي ، يحيث x هو متجه  tf.placeholder بأربعة عناصر:
x = tf.placeholder(tf.int32, shape=[4]) x.get_shape() # (4,) خرج x.get_shape  يمثل ال shape الستاتيكي لـ x ، وتعني (4 ،) أنه متجه بطول 4. الآن دعنا نطبق العملية التالية على x:
y, _ = tf.unique(x) y.get_shape() # (?,) (؟ ،) تعني أن y متجه بطول غير معروف. لماذا هو مجهول؟ تُرجع tf.unique (x) القيم الفريدة من x ، وقيم x غير معروفة لأنها tf.placeholder ، لذلك لا تحتوي على قيمة حتى تقوم بإدخالها. الآن في حالة قمت بإدخال قيمتين مختلفتين:
sess = tf.Session() sess.run(y, feed_dict={x: [0, 1, 2, 3]}).shape # (4,) sess.run(y, feed_dict={x: [0, 0, 0, 0]}).shape # (1,)  إذاً الموتر يمكن أن يكون له شكل ستاتيكي وديناميكي مختلفين. دائماً ما يكون الشكل الديناميكي محدداً تماماً (ليس لها أبعاد وهذا مايشار له ب "؟") لكن الشكل الستاتيكي يمكن أن يكون أقل تحديداً. وهذا ما يسمح لـ TensorFlow بدعم عمليات مثل tf.unique  و tf.dynamic_partition، والتي يمكن أن تحتوي على مخرجات متغيرة الحجم ، وتستخدم في التطبيقات المتقدمة.
الآن اعتقد أن كل شيء واضح والأبعاد التي تبحث عنها أنت هي الأبعاد الستاتيكية لذا استخدم الدالة get_shape

كما أشار أحمد. وفي حالة كان لدينا مستويين للفهرس أي حالة MultiIndex:
import pandas as pd import numpy as np index = pd.MultiIndex.from_product([['TX', 'FL', 'CA'], ['North', 'South']], names=['State', 'Direction']) df = pd.DataFrame(index=index, data=np.random.randint(0, 10, (6,4)), columns=list('abcd')) """ a b c d State Direction TX North 5 7 1 0 South 1 5 7 4 FL North 2 8 1 7 South 5 9 4 0 CA North 0 8 9 0 South 5 7 9 4 """ df.reset_index() """ State Direction a b c d 0 TX North 6 6 2 5 1 TX South 9 1 0 4 2 FL North 2 6 1 4 3 FL South 6 7 6 3 4 CA North 3 3 5 8 5 CA South 7 3 8 1 """ """ #level استخدم المعامل للتحكم في مستويات الفهرس التي يتم تحويلها إلى أعمدة. إذا لم تكن هناك أسماء مستويات ، يمكنك الرجوع إلى كل مستوى من خلال موقعه الصحيح ، والذي يبدأ عند 0 من الخارج. يمكنك استخدام قيمة عددية هنا أو قائمة بجميع الفهارس التي ترغب في إعادة تعيينها. """ df.reset_index(level='State') # نفسها df.reset_index(level=0) """ State a b c d Direction North TX 1 4 2 0 South TX 1 2 8 2 North FL 8 1 9 1 South FL 1 9 6 1 North CA 9 5 5 2 South CA 3 4 6 0 """ """ في بعض الحالات عندما تريد الاحتفاظ بالفهرس وتحويله إلى عمود ، يمكنك القيام بما يلي """ # من أجل مستوى واحد df.assign(State=df.index.get_level_values('State')) """ a b c d State State Direction TX North 2 0 3 6 TX South 2 1 0 0 TX FL North 1 7 4 4 FL South 1 2 7 9 FL CA North 0 0 9 8 CA South 8 8 8 7 CA """ # من أجل كل المستويات df.assign(**df.index.to_frame()) """ a b c d State Direction State Direction TX North 8 7 6 9 TX North South 6 3 1 3 TX South FL North 1 9 2 8 FL North South 4 4 1 7 FL South CA North 8 4 0 7 CA North South 9 8 5 0 CA South """ وفي الحالة العادية يمكنك استخدام الدالة insert أيضاً:
import pandas as pd df = pd.DataFrame({'Roll Number': ['20CSE29', '20CSE49'], 'Name': ['Amelia', 'Sam'], 'Subject': ['Physics', 'Physics']}) df """ Roll Number Name Subject 0 20CSE29 Amelia Physics 1 20CSE49 Sam Physics """ #insert استخدام الدالة df.insert( 0, column="new",value = df.index.values) df """ new Roll Number Name Subject 0 0 20CSE29 Amelia Physics 1 1 20CSE49 Sam Physics """  

الغراف يبقى عبارة عن كود ليس له أي مساحة في الذاكرة أو أي موارد أي مجرد تعليمات إلى أن يتم بناؤه من خلال ال Session. لذا توقعك في مكانه فلايمكننا استخدام if منطقياً هنا (وليس قواعدياً)، لأن الشرط سيتم تقييمه عند بناء الغراف بينما أنت تريد أن يعتمد الشرط على القيمة التي يتم تغذيتها للعنصر النائب placeholder  في زمن التشغيل runtime. لذا فاستخدامك ل if هنا سيؤدي دوماً لاختيار الفرع الأول ل if لأن الشرط الخاص بك سيتم تقييمه على tensor  أي 0<tensor  أي دوماً True.
لذا توفر لنا تنسرفلو الدالة tf.cond للقيام بهذا الأمر  بالشكل الصحيح كمايلي. حيث يقوم بتقييم أحد فرعين، اعتماداً على الحالة المنطقية. لتوضيح كيفية استخدامه، سأعيد كتابة الكود:
data = tensorflow.placeholder(shape=[None, ins_size**2*3]) wights = tensorflow.Variable(tensorflow.zeros([ins_size**2*3,label_option])) bias = tensorflow.Variable(tensorflow.zeros([label_option])) yourcond=tensorflow.placeholder(shape=[1, 1]) #lambda نمرر لها الشرط والفرعين من خلال pred = tensorflow.cond(yourcond > 0, lambda: tensorflow.matmul(data, wights) + bias, tensorflow.matmul(data, wights) - bias)  

يجب عليك إنشاء ارتباط رمزي (ملف اختصار) "symlink" أو كما يسمى أيضاً "link soft" ضمن ال bin بشكل يدوي:
sudo ln -s `which nodejs` /usr/bin/node #غير قياسية shells وإذاكنت تستخدم #node.js للمسار الذي تجد به Hardcoding قم ب sudo ln -s /usr/bin/nodejs /usr/bin/node # Hardcoding: أي استخدام اسم صريح بدلاً من اسم رمزي لشيء من المحتمل أن يتغير في وقت لاحق لحل المشكلة قم بتنقيذ الأوامر التالية:
sudo apt-get --purge remove node sudo apt-get --purge remove nodejs sudo apt-get install nodejs أو:
sudo update-alternatives --install /usr/bin/node node /usr/bin/nodejs 10 عبر npm أو nvm ، يُطلق على Node.js اسم node ولكن إذا قمت بالتثبيت عبر apt-get ، فأنت بحاجة إلى استخدام اسم الحزمة nodejs لأنه من خلال apt-get ، يكون اسم الحزمة مأخوذاً بواسطة تطبيق مختلف تماماً ويسمى أيضاً node.

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

يمكننا القيام بذلك من خلال التعليمة التالية:
%tensorboard --logdir logs/train   لكن يجب أولاً أن نقوم بتحميل الإضافة:
%load_ext tensorboard.notebook أو في حال ظهر لديك الخطأ التالي:
RuntimeError: Use '%load_ext tensorboard' instead of '%load_ext tensorboard.notebook'. قم باستخدام:
%load_ext tensorboard.notebook مثال:
%load_ext tensorboard.notebook import tensorflow as tf import numpy as np logdir = 'logs/' writer = tf.summary.create_file_writer(logdir) tf.summary.trace_on(graph=True, profiler=True) @tf.function def forward_and_backward(x, y, w, b, lr=tf.constant(0.01)): with tf.name_scope('logits'): logits = tf.matmul(x, w) + b with tf.name_scope('loss'): loss_fn = tf.nn.sparse_softmax_cross_entropy_with_logits( labels=y, logits=logits) reduced = tf.reduce_sum(loss_fn) with tf.name_scope('optimizer'): grads = tf.gradients(reduced, [w, b]) _ = [x.assign(x - g*lr) for g, x in zip(grads, [w, b])] return reduced # الدخل x = tf.convert_to_tensor(np.ones([1, 2]), dtype=tf.float32) y = tf.convert_to_tensor(np.array([1])) # params w = tf.Variable(tf.random.normal([2, 2]), dtype=tf.float32) b = tf.Variable(tf.zeros([1, 2]), dtype=tf.float32) loss_val = forward_and_backward(x, y, w, b) with writer.as_default(): tf.summary.trace_export( name='NN', step=0, profiler_outdir=logdir) %tensorboard --logdir logs/ الخرج:

 

engineStrict تم إهمالها على ما اعتقد لذا يمكنك القيام بالتالي:
# معرفة النسخة import semver from 'semver'; import { engines } from './package'; const version = engines.node; if (!semver.satisfies(process.version, version)) { console.log(`Required node version ${version} not satisfied with current version ${process.version}.`); process.exit(1); } # package.json: { "name": "my package", "engines": { "node": ">=50.9" // intentionally so big version number }, "scripts": { "requirements-check": "babel-node check-version.js", "postinstall": "npm run requirements-check" } } #.nvmrc ثم إنشاء ملف

نعم يمكنك القيام بذلك، كالتالي:
# سأقوم بإنشاء نموذج فارغ from keras.models import Sequential model = Sequential() # ثم قم بإنشاء ملف with open(filename + 'report.txt','w') as f: #ليكون قابلاً للاستدعاء lambda قم بتمرير مقبض الملف لل model.summary(print_f=lambda x: f.write(x + '\n')) # وسيكون خرج الملف كالتالي _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= Total params: 0 Trainable params: 0 Non-trainable params: 0 _________________________________________________________________ وإذا أردت كتابته في سجل يمكنك استخدام getLogger من logging:
import logging logger = logging.getLogger(__name__) model.summary(print_fn=logger.info)  

حسناً.. افترض أنك ترغب في تشغيل operator معين في كل مرة يتم فيها تقييم متغير معين. على سبيل المثال ، لنفترض أنك ترغب في إضافة واحد إلى c في كل مرة يتم فيها تقييم المتغير k. قد يبدو لك أن هذا الكود سيعمل:
c = tf.Variable(0.0) cp = tf.assign_add(c, 1) with tf.control_dependencies([cp]): k = c init = tf.initialize_all_variables() with tf.Session() as session: init.run() for i in xrange(4): print(k.eval()) #0, 0, 0, 0 # لكن كما تلاحظ لم ينجح الأمر وذلك لأننا بحاجة إلى إضافة عقدة جديدة إلى الرسم البياني داخل كتلة control_dependencies. لذلك في مثل هكذا حالة يمكننا أن نستخدم tf.identity حيث يضيف عقدة وهمية:
c = tf.Variable(0.0) cp = tf.assign_add(c, 1) with tf.control_dependencies([cp]): k = tf.identity(c) init = tf.initialize_all_variables() with tf.Session() as session: init.run() for i in xrange(4): print(k.eval()) # 1, 2, 3, 4 وبشكل عام هو مفيد أيضاً عندما تريد نقل tensor بين الأجهزة (مثلاً ، من ال GPU إلى ال CPU). حيث يضيف op عقد الإرسال / الاستلام إلى الغراف ، مما يؤدي إلى إنشاء نسخة عندما تختلف أجهزة الإدخال والإخراج. إن السلوك الافتراضي هو أن تتم إضافة عقد الإرسال / الاستلام ضمنياً عندما تحدث العملية على جهاز مختلف ولكن يمكنك تخيل بعض المواقف (خاصة في الإعدادات multi-threaded/distributed ) عندما يكون من المفيد جلب قيمة المتغير عدة مرات خلال عملية تنفيذ واحدة للجلسة. يسمح tf.identity بمزيد من التحكم فيما يتعلق بوقت قراءة القيمة من الجهاز المصدر.

بالنسبة لـ Angular 1.0 يجب استخدام $interpolateProvider مثلاً:
myModule.config(function($interpolateProvider) { $interpolateProvider.startSymbol('{[{'); $interpolateProvider.endSymbol('}]}'); }); لكن يجب أن تدرك أن الخلط بين القوالب من جانب الخادم والعميل ليس أمراً جيداً، وفي حال أردت ذلك فيجب أن تقوم بالأمر بحذر. والأمور الرئيسية هنا هي: أولاً-قابلية الصيانة (لأنها صعبة القراءة. وثانياً الأمن حيث يمكن أن يؤدي double interpolation إلى كشف security vector جديد. وهذه المشاكل لن نستطيع التعامل معها سوى التحذير. مشكلة أخرى وهي إذا بدأت في استخدام توجيهات third-party التي تستخدم {{}} في نماذجها، فإن التهيئة الخاصة بك ستؤدي إلى تعطيلها. وهذه المشكلة يجب أن يتم حلها.
وكحل آخر فإنك إذا قمت بفصل أقسام الصفحة بشكل صحيح ، فيمكنك بسهولة استخدام angularjs tags في نطاق الوسم "raw".
#jinja2 في {% raw %} //angularjs هنا يمكنك كتابة سمات قالب {% endraw %} #Django في قالب {% verbatim %} //angularjs هنا يمكنك كتابة سمات قالب {% endverbatim %}  

نعم يمكنك استخدام reset_default_graph من ops كالتالي:
from tensorflow.python.framework import ops ops.reset_default_graph() sess = tf.InteractiveSession()  

كما نعلم فإن الأوزان بتم تمثيلها ك tf.Variable  في تنسرفلو وهذا ال Variable  يمكنك الحصول على قيمته من خلال sess.run(Variable)، الآن إذا أردت الحصول عليه فيمكنك الحصول على قائمة بالمتغيرات Variables  القابلة للتدريب (من ضمنها ستكون الأوزان) في الغراف الحالي عن طريق استدعاء tf.trainable_variables. ثم يمكنك الحصول على المتغير الذي تريده من خلال  تحديد الخاصية Variable.name. انظر للمثال التالي:
#"conv2d/kernel:0" بفرض اسم المتغير الذي نريده هو var = [variable for variable in tf.trainable_variables() if variable.name == "conv2d/kernel:0"][0]