Ali Haidar Ahmad

الاختلاف الوحيد بينهم هو أن الجلسة التفاعلية "InteractiveSession" تقوم بتثبيت نفسها كجلسة افتراضية عند بناء الغراف (أي إذا لم تعرف أي جلسة بشكل صريح سيتم استخدامها كجلسة افتراضية).  انظر مثلاً عندما نقوم بتعريف جلسة عادية لمقطع برمجي في تنسرفلو نقوم بالتالي:
import tensorflow.compat.v1 as tf tf.disable_v2_behavior() with tf.Session() as sess: a = tf.constant(4.0) b = tf.constant(2.0) c = a * b print(sess.run(c)) أما باستخدام InteractiveSession:
sess = tf.InteractiveSession() a = tf.constant(4.0) b = tf.constant(2.0) c = a * b #sess.run مباشرةً دون الحاجة لتمريرها ل c.eval() لاحظ أننا نستطيع تنفيذ print(c.eval()) sess.close() #8.0  

إكما يمكنك القيام بذلك من خلال json_normalize كالتالي (بدون urllib2):
import requests from pandas import json_normalize url = .. response = requests.get(url) dictr = response.json() recs = dictr['result']['records'] df = json_normalize(recs) print(df) أو كالتالي (ينصح بالطريقة الأولى):
#json.load من خلال JSON نقوم بقراءة بيانات f = 'jsondata.json' with open(f) as j: dict_train = json.load(j.read()) #DataFrame إلى json تحويل مجموعة بيانات df = pd.DataFrame.from_dict(dict_train, orient='index') df.reset_index(level=0, inplace=True)

يمكنك القيام بذلك كالتالي:
import numpy as np import pandas as pd # إنشاء داتا فريم ببيانات عشوائية df = pd.DataFrame(np.random.random((10, 2))) df['date'] = pd.date_range('2017-1-1', periods=10, freq='D') df """ 0 1 date 0 0.398304 0.199462 2017-01-01 1 0.298642 0.960583 2017-01-02 2 0.172924 0.955810 2017-01-03 3 0.802121 0.691403 2017-01-04 4 0.584322 0.949568 2017-01-05 5 0.499019 0.667226 2017-01-06 6 0.069219 0.153963 2017-01-07 7 0.951769 0.758855 2017-01-08 8 0.485271 0.415563 2017-01-09 9 0.330080 0.561897 2017-01-10 """ # سنختار البيانات التي تقع ضمن التاريخ # "2017-01-3", "2017-01-6" range = df[df["date"].isin(pd.date_range("2017-01-3", "2017-01-6"))] range """ 0 1 date 2 0.722369 0.145827 2017-01-03 3 0.540575 0.378795 2017-01-04 4 0.341897 0.406917 2017-01-05 5 0.919453 0.810913 2017-01-06 """ أو الحل الأبسط وهو إنشاء استعلام كالتالي:
start_date, end_date = "2017-01-3", "2017-01-6" df.query('date >= @start_date and date <= @end_date') """ 0 1 date 2 0.722369 0.145827 2017-01-03 3 0.540575 0.378795 2017-01-04 4 0.341897 0.406917 2017-01-05 5 0.919453 0.810913 2017-01-06 """ أو يمكنك استخدام df.loc بعد أن تحدد له البداية والنهاية كالتالي:
start = df[df['date']=='2017-01-03'].index[0] end = df[df['date']=='2017-01-6'].index[0] df.loc[start:end] """ 0 1 date 2 0.722369 0.145827 2017-01-03 3 0.540575 0.378795 2017-01-04 4 0.341897 0.406917 2017-01-05 5 0.919453 0.810913 2017-01-06 """  

المشكلة تحدث بسبب ال GPU وغالباً ما يسببها وجود عمليتين تتنافسان على ال GPU. أي أن هناك عملية ما تستخدم ال GPU الآن. لذا قم بإغلاق الجلسات التفاعلية "interactive sessions" في العمليات الأخرى (إذا كنت تستخدم جوبيتر قم بإعادة تشغيل الكيرنل) أو استخدم الكود التالي لإغلاق الجلسات المحلية الأخرى:
if 'session' in locals() and session is not None: print('Close interactive session') session.close() أو يمكنك أن تضبط allow_soft_placement على Trueو gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.3) وبالتالي تحديد نسبة ال GPU التي ستستخدم في الجلسة:
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.3) sess = tf.Session(config=tf.ConfigProto( allow_soft_placement=True, log_device_placement=True))

لإيقاف التنفيذ الفوري (الحثيث) نستخدم disable_eager_execution من v1 API حيث نضعها في بداية الكود:
import tensorflow as tf tf.compat.v1.disable_eager_execution() أو من خلال tensorflow.python.framework.ops كالتالي:
import tensorflow as tf from tensorflow.python.framework.ops import disable_eager_execution disable_eager_execution() a = tf.constant(1) b = tf.constant(2) c = a + b print(c)  

لا .. لا تتضمن Keras أي وسيلة لتصدير غراف TensorFlow كملف بامتداد pd، ولكن يمكنك القيام بذلك بنفسك من خلال TensorFlow. وتحديداُ من خلال freeze_graph.py وهي الطريقة "النموذجية" التي يتم القيام بها، حيث:
- يجمد حالة الجلسة في بيان مجتزأ. - يقوم بإنشاء graph جديد حيث يتم استبدال عقد المتغيرات بالثوابت التي تأخذ قيمتها الحالية في الجلسة. - سيتم تجزيئ الغراف الجديد بحيث تتم إزالة ال subgraphs غير الضرورية لحساب المخرجات المطلوبة.
def freeze_session(session, keep_var_names=None, output_names=None, clear_devices=True): graph = session.graph with graph.as_default(): freeze_var_names = list(set(v.op.name for v in tf.global_variables()).difference(keep_var_names or [])) output_names = output_names or [] output_names += [v.op.name for v in tf.global_variables()] input_graph_def = graph.as_graph_def() if clear_devices: for node in input_graph_def.node: node.device = "" frozen_graph = tf.graph_util.convert_variables_to_constants( session, input_graph_def, output_names, freeze_var_names) return frozen_graph - الوسيط session: جلسة تنسرفلو التي سيتم تجميدها. - keep_var_names قائمة بأسماء المتغيرات التي لا يجب أن بتم تجميدها،وفي حال تم ضبطه على None  سيتم تجميد كل المتغيرات في البيان. - output_names:هي قائمة بأسماء العمليات التي تنتج المخرجات التي تريدها. - clear_devices: لتحسين إمكانية النقل يتم ضبطه على True. وبالتالي يمكنك استخدامه كالتالي:
from keras import backend as K # قم ببناء نموذجك frozen_graph = freeze_session(K.get_session(),output_names=[out.op.name for out in model.outputs]) ثم يمكنك كتابة البيان في ملف باستخدام tf.train.write_graph:
tf.train.write_graph(frozen_graph, "path", "my_model.pb", as_text=False)

أولاً from_tensors تقوم بإنشاء dataset من خلال دمج المدخلات الممررة لها كعنصر واحد (كتلة واحدة) أي مثلاً:
data = tf.constant([[4, 5], [1, 7]]) dataset = tf.data.Dataset.from_tensors(data) [x for x in dataset] """ #data لاحظ أن الخرج هو عبارة عن مصفوفة واحدة تمثال ال [<tf.Tensor: shape=(2, 2), dtype=int32, numpy= array([[4, 5], [1, 7]], dtype=int32)>] """ بينما from_tensor_slices تقوم بإنشاء dataset وتعيد عدة عناصر منفصلة بحيث كل عنصر يمثل صف من الإدخال الممرر لها أي:
data = tf.constant([[4, 5], [1, 7]]) dataset = tf.data.Dataset.from_tensor_slices(data) [x for x in dataset] """ # لاحظ أن كل سطر من الدخل تم تمثيله بشكل مستقل [<tf.Tensor: shape=(2,), dtype=int32, numpy=array([4, 5], dtype=int32)>, <tf.Tensor: shape=(2,), dtype=int32, numpy=array([1, 7], dtype=int32)>] """ أيضاً هناك اختلاف عندما يكون الدخل هو قائمة، حيث أن from_tensors تقوم بإنشاء tensor ثلاثي الأبعاد أما from_tensor_slices  تقوم بدمجهم وتعيد 2D. مثلاً:
dataset1 = tf.data.Dataset.from_tensor_slices( [tf.random_uniform([2, 3]), tf.random_uniform([2, 3])]) dataset2 = tf.data.Dataset.from_tensors( [tf.random_uniform([2, 3]), tf.random_uniform([2, 3])]) print(dataset1) # shapes: (2, 3) print(dataset2) # shapes: (2, 2, 3)

يمكنك القيام بذلك من خلال الدالة merge لكن في البداية يجب أن تضيف مفتاح لكي تتم عملية الدمج عليه كالتالي:
df1['key'] = 0 df2['key'] = 0 df1.merge(df2, how='left',on = 'key').drop(columns=['key']) """ col1 col2 col3 0 1 3 5 1 1 3 6 2 2 4 5 3 2 4 6 """ df1['key'] = 0 df2['key'] = 0 df1.merge(df2, how='left',on = 'key').drop(columns=['key']) """ col1 col2 col3 0 1 3 5 1 1 3 6 2 2 4 5 3 2 4 6 """ # أو df1.merge(df2, how='outer').drop(columns=['key']) # حسبما تريد # لكن بالضرورة يجب أن تضيف مفتاح أو من خلال التابع التالي:
import pandas as pd def cartesian(df1, df2): key = 'key' while key in df1.columns or key in df2.columns: key = '_' + key key_d = {key: 0} return pd.merge(df1.assign(**key_d), df2.assign(**key_d), on=key).drop(key, axis=1) cartesian(df1, df2) """ col1 col2 col3 0 1 3 5 1 1 3 6 2 2 4 5 3 2 4 6 """  

CharField هو حقل خاص بالسلاسل النصية "string field"، ويستخد للسلاسل صغيرة إلى كبيرة الحجم. وهو مثل حقل السلسلة في C / C ++. و يستخدم CharField بشكل عام لتخزين سلاسل صغيرة مثل الاسم الأول واسم العائلة وما إلى ذلك. أما لتخزين نص أكبر يتم استخدام TextField. أداة النموذج الافتراضية لهذا الحقل هي TextInput.
يحتوي CharField على وسيطة إضافية مطلوبة: CharField.max_length أقصى طول للحقل (بعدد المحارف). ويتم فرض هذا ال max_length على مستوى قاعدة البيانات وفي Django’s validation باستخدام MaxLengthValidator. وله الشكل التالي:
field_name = models.CharField(max_length=200, **options) كما ذكرت يستخدم CharField لتخزين سلاسل صغيرة الحجم في قاعدة البيانات. يمكننا مثلاً تخزين الاسم الأول واسم العائلة وتفاصيل العنوان وما إلى ذلك. ويجب إعطاء CharField وسيطة max_length لتحديد الحد الأقصى لطول السلسلة المطلوب تخزينها. في ال production server ، بعد نشر تطبيق Django ، تكون المساحة محدودة للغاية. لذلك من الأفضل دائماً استخدام max_length وفقًا لمتطلبات الحقل.
TextField عبارة عن حقل نصي كبير من أجل النصوص كبيرة الحجم. ويستخدم TextField بشكل عام لتخزين الفقرات وجميع البيانات النصية الأخرى (يستخدم لتخزين نص كبير في قاعدة البيانات أما في حال أردنا تخزين نص صغير نستخدم charfield). عنصر واجهة المستخدم الافتراضي لهذا الحقل هو TextArea. وله الشكل التالي: field_name = models.TextField( **options) أيضاً تستخدم CharFields عادةً للأشياء القابلة للبحث، مثل إذا كنت تريد البحث عن "one" في السلسلة "one plus two". نظرًا لأن السلسلة النصية تكون أقصر، فإنها تستغرق وقتاً أقل للمحرك للبحث من خلالها. أيضاً فإن أقصى حد لطول السلسلة فيه هو 255.

اعتبارًا من TensorFlow 0.8 ، يمكنك استخدام  tf.one_hot  للقيام بتحويل ال labels إلى تمثيل ال One-Hot_Encoding. مثال عليها لنفرض أن لديك 4 فئات(قطة 0 ، كلب 1 ، طائر 2 ، إنسان 3) ولدينا عينتان هما (قط و إنسان) أي 0 و 3.
import tensorflow.compat.v1 as tf tf.disable_v2_behavior() res = tf.one_hot(indices=[0, 3], depth=4) # نحدد العمق على 4 لأنه لدينا 4 فئات with tf.Session() as sess: print (sess.run(res)) """ [[1. 0. 0. 0.] [0. 0. 0. 1.]] """ بالإضافة إلى ذلك إذا أحببت هناك tf.nn.sparse_softmax_cross_entropy_with_logits، والتي تيح لك حساب الانتروبيا المتقاطعة مباشرة على ال labels  (طبعاً Spare Labels) بدلاً من الحاجة إلى تحويلها إلى One-Hot.

الخطأ يشير إلى أن نسخة pip التي قمت بتثبيت protobuf من خلالها قديمة وبالتالي قد تتسبب لك في أخطاء بالتثبيت مثل هذا الخطأ (لاحظ أنه لم يعطيك خطأ عند استيراد ops وإنما فقط عند استيراد label_map_util لذا فغالباً المشكلة إما في نظام إدارة الحزم لديك pip أو أنه حدث خطأ ما أثناء تثبيتها). لذا في الحالتين قم بتنفيذ الأوامر التالية:
pip uninstall protobuf python3-protobuf pip install --upgrade pip # لتحديث مدير الحزم pip install --upgrade protobuf

أولاً ماهو ال iterator: المكرر هو كائن يحتوي على عدد قابل للعد من القيم. وهو كائن يمكن التكرار عليه، مما يعني أنه يمكنك المرور على جميع القيم فيه. وبشكل عميق أكثر في Python ، المكرر هو كائن يقوم بتنفيذ بروتوكول المكرر، والذي يتكون من الطريقتين __iter __ () و __next __ ().
لدينا مفهومين في بايثون وهما Iterator و Iterable.  نعتبر أن ال Lists, tuples, dictionaries,set كائنات قابلة للتكرار وتعتبر حاويات متكررة "iterable containers" يمكنك الحصول على مكرر "Iterator " منها وحتى السلاسل Strings هي كائنات قابلة للتكرار، ويمكنك الحصول على مكرر منها. وجميعهم يمتلكون الطريقة ()iter التي تستخدم للحصول على مكرر Iterator منها:
li = ["argentena", "barca", "ali"] iterator = iter(li) print(next(iterator)) print(next(iterator)) print(next(iterator)) """ argentena barca ali """ مثال عن String:
li = "argentena" iterator = iter(li) print(next(iterator)) print(next(iterator)) print(next(iterator)) """ a r g """ يمكنك أيضاً المرور على عناصر المكرر من خلال الحلقات مثلاً:
li = "argentena" iterator = iter(li) for x in iterator: print(x) """ a r g e n t e n a """ مثال عن tuple:
mytuple = ("apple", "banana", "cherry") iterator = iter(mytuple) for x in iterator: print(x) """ apple banana cherry """ أما إذا أردنا إنشاء class كمكرر فيجب علينا تحقيق الطريقتين __iter __ () و __next __ () في الكائن الخاص بك. وكما نعلم جميعاً فإن الكائنات في بايثون تملك دالة (طريقة) تسمى __init __ () ، والتي تتيح لنا القيام بعمليات تهيئة عند إنشاء كائن من الصف. إن الدالة __iter __ ()  تعمل بشكل مشابه لها، حيث يمكنك القيام بالعمليات (التهيئة وما إلى ذلك) ، ولكن يجب دائماً إرجاع كائن المكرر نفسه.
أيضاً تسمح لك الدالة __next __ () بإجراء عمليات، ويجب أن تعيد العنصر التالي في التسلسل.مثال:
class num: def __iter__(self): self.i = 1 return self #التي تشير إلى الكائن نفسه self لاحظ أننا قمنا بإرجاع def __next__(self): a = self.i self.i += 1 return a myclass = num() myiter = iter(myclass) print(next(myiter)) print(next(myiter)) print(next(myiter)) print(next(myiter)) """ 1 2 3 4 """ for i in myclass: print(i) if i==7: break """ 1 2 3 4 1 2 3 4 5 6 7 """ في المثال السابق ستستمر حلقة for إلى اللانهاية لو لم نضع break، لذا يمكننا استخدام StopIteration حيث نضيفها في طريقة __next __ () ، كشرط للإنهاء إذا تم التكرار لعدد محدد من المرات:
class num: def __iter__(self): self.i = 1 return self #التي تشير إلى الكائن نفسه self لاحظ أننا قمنا بإرجاع def __next__(self): a = self.i self.i += 1 return a def __next__(self): if self.i <= 10: a = self.i self.i += 1 return a else: raise StopIteration myclass = num() for i in myclass: print(i) """ 1 2 3 4 5 6 7 8 9 10 """ هذا كل شيء تحتاجه عن المكررات.

يمكنك تعيين متغيرات environment في ال notebook باستخدام os.environ. حيث يجب أن تقوم بما يلي قبل تهيئة TensorFlow وذلك لقصر TensorFlow على GPU الأول (جعله يستخدم أول Gpu فقط):
import os os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICES"]="0" #وتريد تفعيل عدد محدد منها Gpu في حالة كان لديك 4 وحدات import os os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICES"]="0,2,3" #هنا Gpu نضع مانريده من ال وبالتالي سيتم قصر تنسرفلو على أول gpu فقط، حيث سيتم إخفاء الثاني عنه، وللتأكد يمكنك استخدام الكود التالي:
import notebook_util notebook_util.pick_gpu_lowest_memory() import tensorflow as tf # أو from tensorflow.python.client import device_lib print device_lib.list_local_devices() حيث سيعرضان لك قائمة الأجهزة المرئية (غير المخفية).

إليك العديد من الطرق:
import pandas as pd df = pd.DataFrame({'c1': ['100','DDD','646','XYZ','888'], 'c2': ['AAA','000','999','500','1000'] }) #لنجرب عليها Nan جعل بعض القيم df = df.apply (pd.to_numeric, errors='coerce') df """ c1 c2 0 100.0 NaN 1 NaN 0.0 2 646.0 999.0 3 NaN 500.0 4 888.0 1000.0 """ ############################ استخدام pd.notnull ################################## df[pd.notnull(df['c2'])] """ c1 c2 1 NaN 0.0 2 646.0 999.0 3 NaN 500.0 4 888.0 1000.0 """ ############################# isnull ############################################ df[~df.c2.isnull()] """ c1 c2 1 NaN 0.0 2 646.0 999.0 3 NaN 500.0 4 888.0 1000.0 """ ############################# isnan ########################################## df[~np.isnan(df.c2)] """ c1 c2 1 NaN 0.0 2 646.0 999.0 3 NaN 500.0 4 888.0 1000.0 """ ######################### أو بالشكل العبقري التالي ########################## df.query("c2 == c2") # np.nan==np.nan # False """ c1 c2 1 NaN 0.0 2 646.0 999.0 3 NaN 500.0 4 888.0 1000.0 """ ############################ dropna حل آخر وهو استخدام ########################### df.dropna() #nan ستؤدي لحذف كل صف يحوي قيم """ c1 c2 2 646.0 999.0 4 888.0 1000.0 """ # بعد عملية الحذف سيكون الفهرس مبعثر كما رأينا لذا يجب أن نقوم بإعادة ضيطه # df.reset_index(drop=True) df.dropna(subset=['c2']) # ستؤدي لحذف الصف الأول فقط """ c1 c2 1 NaN 0.0 2 646.0 999.0 3 NaN 500.0 4 888.0 1000.0 """ #على الأقل nan لحذف الصف في حال احتوى على قيمتي df.dropna(thresh=2) # يمكنك تحديد العدد الذي يناسبك #يو how='all' استخدام df["c2"].dropna(how='all')  

يمكنك القيام بذلك من خلال الدالة assign كالتالي:
import pandas as pd df = pd.DataFrame({'Year': ['2020', '2021'], 'month': ['june', 'july']}) df """ Year month 0 2020 june 1 2021 july """ df = df.assign(period = df.Year.astype(str) + '-' + \ df.month.astype(str)) df """ Year month period 0 2020 june 2020-june 1 2021 july 2021-july """ أو باستخدام الدالة apply وتطبيق lambda على كل سطر من البيانات:
import pandas as pd df = pd.DataFrame({'Year': ['2020', '2021'], 'month': ['june', 'july']}) df """ Year month 0 2020 june 1 2021 july """ df['period'] = df[df.columns[0:]].apply( lambda x: '-'.join(x.dropna().astype(str)), axis=1 ) df """ Year month period 0 2020 june 2020-june 1 2021 july 2021-july """  

يمكنك معرفة الدقة Accuracy و ال loss للنموذج من خلال الدالة evaluate، حيث لها الشكل التالي:
Model.evaluate( x=None, y=None, batch_size=None, verbose=1, sample_weight=None, steps=None, callbacks=None, return_dict=False ) # أو بالشكل المختصر Model.evaluate( x=None, y=None ) حيث أن x  يشير إلى بيانات الدخل (بيانات الاختبار)، ويجب أن يكون مصفوفة نمباي (أو نوع آخر يشابهها)، أو قائمة من المصفوفات "list of arrays" (في حالة كان نموذجك متعدد الدخل multiple inputs). أو يمكن أن تكون مصفوفة تنسر "TensorFlow tensor" أو قائمة من التنسر "list of tensors" (في حالة كان نموذجك متعدد الدخل multiple inputs). أو قاموس يربط اسم بمصفوفة أو تنسر في حال كان لمصفوفات الدخل أسماء. أو tf.data مجموعة بيانات مكونة من خلال تنسرفلو، بحيث تكون من الشكل (inputs, targets) أو (inputs, targets, sample_weights).أو مولد generator أو تسلسل keras.utils.Sequence بحيث يعيد (inputs, targets) أو (inputs, targets, sample_weights).
أما ثاني وسيطة y هي بيانات الهدف أو ال Target أو ال label، وبشكل مشابه لبيانات الدخل x يجب أن تكون Numpy array(s) أو TensorFlow tensor(s)، ويجب أن تكوم متسقة مع x، أي بمعنى إذا كانت x تحوي 400 عينة فهذا يعني أنه يجب أن يكون لدينا 400 target، و لايجب أن يكون x نمباي و y تنسر أو العكس. وفي حالة كانت بيانات الإدخال x من النوع dataset, generator, أو keras.utils.Sequence فلا تقم بتمرير قيم ال y لأنهم يحصلون علبها بشكل تلقائي من خلال x.
 الوسيط الثالث هو ال batch_size وهو يمثل حجم دفعة البيانات، وهو عدد صحيح يشير إلى عدد العيانات التي سيتم تطبيق خوارزمية الانتشار الأمامي  عليها لحساب القيم المتوقعة. في حالة كانت بيانات الإدخال x من النوع dataset, generator, أو keras.utils.Sequence فلاتقم بتحديد هذا الوسيط لأنهم في الأساس يقومون بتوليد باتشات. وأيضاً في حالة لم تقوم بتعيين قيمة للباتش "None" فسأخذ القيمة الافتراضية 32. 
الوسيط الرابع هو ال verbose لعرض تفاصيل عملية التوقع في حال ضبطه على 0 لن تظهر لك التفاصيل "أي الوضع الصامت"، أما في حالة ضبطه على 1 فهذا يعني أنك تريد أن تظهر لك التفاصيل.
الوسيط الخامس sample_weight هو مصفوفة أوزان (اختياري) لعينات التدريب وتستخدم أيضاً لتوزين دالة التكلفة.ويمكنك إما تمرير مصفوفة Numpy مسطحة (1D) بنفس طول عينات الإدخال (ربط 1: 1 بين الأوزان والعينات). أو في حالة البيانات الزمنية ، يمكنك تمرير مصفوفة ثنائية الأبعاد ذات شكل (عينات ، طول التسلسل) ، لتطبيق وزن مختلف لكل خطوة زمنية لكل عينة. وهذه الخاصية غير مدعومة في حالة كانت بيانات الإدخال x من النوع dataset, generator, أو keras.utils.Sequence.. 
الوسيط steps هو عدد صحيح أو None إجمالي عدد الخطوات (مجموعات العينات) قبل الإعلان عن انتهاء حقبة واحدة وبدء المرحلة التالية. عند التدريب باستخدام موترات الإدخال مثل TensorFlow data tensors ، فإن القيمة الافتراضيةNone تساوي عدد العينات في مجموعة البيانات الخاصة بك مقسوماً على حجم الباتش، أو 1 إذا تعذر تحديد ذلك. إذا كانت x عبارة عن tf.data ، وكانت "steps=" None ، فسيتم تشغيل الحقبة حتى يتم استنفاد مجموعة بيانات الإدخال. وهذه الوسيطة غير مدعومة عندما تكون مدخلاتك هي مصفوفات.
الوسيط callbacks هو قائمة من keras.callbacks.Callback وهي قائمة الاسترجاعات المطلوب تقديمها أثناء التقييم.
الوسيط الأخير في حالة ضبطه على True ٍيتم تخزين النتائج (التكلفة loss والدقة acc ) في قاموس وإلا سيتم التخزين ضمن قائمة.
مثال:
from keras.datasets import imdb from keras.preprocessing import sequence max_features = 10000 maxlen = 100 batch_size = 32 print('Loading data...') (input_train, y_train), (input_test, y_test) = imdb.load_data( num_words=max_features) print(len(input_train), 'train sequences') print(len(input_test), 'test sequences') print('Pad sequences (samples x time)') input_train = sequence.pad_sequences(input_train, maxlen=maxlen) input_test = sequence.pad_sequences(input_test, maxlen=maxlen) print('input_train shape:', input_train.shape) print('input_test shape:', input_test.shape) from keras.layers import Dense,Embedding,SimpleRNN model = Sequential() model.add(Embedding(max_features, 32)) model.add(SimpleRNN(32)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) history = model.fit(input_train, y_train, epochs=4, batch_size=128, validation_split=0.2) ################################ results = model.evaluate(input_test, y_test,verbose=1) # 782/782 [==============================] - 7s 8ms/step - loss: 0.4739 - acc: 0.8250 results # [0.4739033281803131, 0.824999988079071]  

بمكنك القيام بذلك من خلال الدالة mask:
import pandas as pd import numpy as np df = pd.DataFrame({'Date' : ['11/8/2011', '11/9/2011', '11/10/2011', '11/11/2011', '11/12/2011'], 'Event' : ['Dance', 'Painting', 'Dance', 'Dance', 'Painting']}) df """ Date Event 0 11/8/2011 Dance 1 11/9/2011 Painting 2 11/10/2011 Dance 3 11/11/2011 Dance 4 11/12/2011 Painting """ #Hip-Hop بال Dance استبدال ال df['Event'].mask(df['Event'] == 'Dance', 'Hip-Hop', inplace=True) #لكي يتم التعديل على البيانات الأصلية inplace==True نضع df """ Date Event 0 11/8/2011 Hip-Hop 1 11/9/2011 Painting 2 11/10/2011 Hip-Hop 3 11/11/2011 Hip-Hop 4 11/12/2011 Painting """ ,أو باستخدام df.where:
import pandas as pd import numpy as np df = pd.DataFrame({'Date' : ['11/8/2011', '11/9/2011', '11/10/2011', '11/11/2011', '11/12/2011'], 'Event' : ['Dance', 'Painting', 'Dance', 'Dance', 'Painting']}) #Hip-Hop بال Dance استبدال ال m = df.Event == 'Dance' df.where(~m,other='Hip-Hop') أو من خلال np.where:
import pandas as pd import numpy as np df = pd.DataFrame({'Date' : ['11/8/2011', '11/9/2011', '11/10/2011', '11/11/2011', '11/12/2011'], 'Event' : ['Dance', 'Painting', 'Dance', 'Dance', 'Painting']}) #Art بال Painting استبدال ال df['Event'] = np.where((df.Event == 'Painting'),'Art',df.Event) df """ Date Event 0 11/8/2011 Dance 1 11/9/2011 Art 2 11/10/2011 Dance 3 11/11/2011 Dance 4 11/12/2011 Art """ إضافة للطريقة التي قدمها أحمد وهي iloc:
import pandas as pd import numpy as np df = pd.DataFrame({'Date' : ['11/8/2011', '11/9/2011', '11/10/2011', '11/11/2011', '11/12/2011'], 'Event' : ['Dance', 'Painting', 'Dance', 'Dance', 'Painting']}) #Hip-Hop بال Dance استبدال ال df.loc[(df.Event == 'Dance'),'Event']='Hip-Hop' df """ Date Event 0 11/8/2011 Hip-Hop 1 11/9/2011 Painting 2 11/10/2011 Hip-Hop 3 11/11/2011 Hip-Hop 4 11/12/2011 Painting """  

يمكنك استخدام select_related عندما يكون الكائن الذي ستحدده كائن واحد، وبالتالي OneToOneField أو ForeignKey. ويمكنك استخدام prefetch_related عندما تحصل على "set" من الأشياء ، لذا ManyToManyFields كما ذكرت أو reverse ForeignKeys.والمثال التالي لتفهم أكثر المقصود ب reverse ForeignKeys:
class mymodel(models.Model): pass class my2(models.Model): f = ForeignKey(mymodel) # علاقة Forward ForeignKey my2.objects.select_related('f').all() # Reverse ForeignKey mymodel.objects.prefetch_related('modelb_set').all() الفرق هو أن select_related يقوم بضم SQL وبالتالي يحصل على النتائج مرة أخرى كجزء من الجدول من خادم SQL. من ناحية أخرى ، ينفذ prefetch_related استعلامًا آخر وبالتالي يقلل من الأعمدة الزائدة في الكائن الأصلي أي يكافئ mymodel في المثال التالي. يمكنك استخدام prefetch_related لأي شيء يمكنك استخدام select_related له. الاختلافات أو المفاضلات بينهما هي أنه يجب على prefetch_related إنشاء وإرسال قائمة بالمعرفات للاختيار مرة أخرى إلى الخادم، وقد يستغرق ذلك بعض الوقت. حيث أن Django يرسل قائمة ويطلب فيها تحديد بعض المعلومات. وفي هذه الحالة إذا كانت البيانات التي تم جلبها مسبقاً متناثرة، فقد يكون هذا أمراً جيداً، ولكن إذا كانت أقرب إلى one-to-one، فقد يؤدي ذلك إلى إهدار الكثير من الاتصالات. أيضاً هناك فائدة ل prefetch_related إضافية تتمثل في استخدام كائن واحد لتمثيل كل كائن في قاعدة البيانات. أما باستخدام select_related، سيتم إنشاء كائنات مكررة في Python لكل كائن "parent". وكما نعلم فإن الكائنات في Python تحجز حجم كبير من الذاكرة، وهذا أمر سلبي.

الغراف Graph يقوم بتمثيل العمليات والمتغيرات التي قمت بتعريفها في الكود وتحديد العلاقات بينها على شكل عقد تشكل مجتمعةً البيان أي ال Graph . وهو لا يحسب أي شيء، ولا يحتفظ بأي قيم، هو فقط يحدد العمليات التي حددتها في التعليمات البرمجية الخاصة بك (الكود الذي كتبته).
أما  Session تسمح بتنفيذ  ال graph أو جزء منه إذ يقوم بتنفيذ كل العقد node الموجودة في البيان وينفذ العمليات فيه ويحمل القيم الفعلية للنتائج والمتغيرات الوسيطية . ويقوم بتخصيص الموارد (على جهاز واحد أو أكثر) لتنفيذ هذه المهام. مثلاً هنا لدينا غراف مع 3 متغيرات و 3 عمليات:
graph = tf.Graph() with graph.as_default(): variable = tf.Variable(42, name='foo') # تعريف متغير initialize = tf.global_variables_initializer() # يعين القيمة الأولية 42 لهذا المتغير assign = variable.assign(13) # يعين القيمة الجديدة 13 لهذا المتغير أيضاً تجدر الملاحظة إلى أنك لست مجبراً على كتابة أول سطرين، فتنشرفلو تقوم بإنشاء غراف افتراضي لك (أي لست مضطراً لتعريفه بنفسك).
الآن لتنفيذ أي من العمليات الثلاث المحددة، نحتاج إلى إنشاء جلسة لهذا البيان. حيث ستخصص الجلسة أيضاً ذاكرة لتخزين القيمة الحالية للمتغير variable. 
with tf.Session(graph=graph) as sess: sess.run(initialize) sess.run(assign) print(sess.run(variable)) # Output: 13 أيضاً يجب أن تدرك أن قيمة المتغير صالحة فقط خلال جلسة واحدة. إذا حاولنا الاستعلام عن القيمة بعد ذلك في جلسة ثانية، فسيقوم TensorFlow بإعطاء خطأ لأن المتغير لم تتم تهيئته هناك.
with tf.Session(graph=graph) as sess: print(sess.run(variable)) # Error: Attempting to use uninitialized value foo وبالطبع ، يمكننا استخدام البيان في أكثر من جلسة، حيث علينا فقط إعادة تهيئة المتغيرات مرة أخرى.  لكن ستكون القيم في الجلسة الجديدة مستقلة تماماً عن الأولى:
with tf.Session(graph=graph) as sess: sess.run(initialize) print(sess.run(variable)) # Output: 42

لاتوجد طريقة في تنسرفلو للقيام بذلك مع أنها مهمة، لذلك نلجأ لاستخدام Timeline للحصول على وقت التنفيذ لكل عقدة في البيان، لكنن هنا يجب أن نقوم بضبط كل من الوسيطيتين options و run_metadeta كما في المثال التالي:
import tensorflow as tf from tensorflow.python.client import timeline x = tf.random_normal([500, 500]) y = tf.random_normal([500, 500]) res = tf.matmul(x, y) with tf.Session() as sess: run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) # نقوم بتشغيل الغراف مع خيار التتبع الكامل run_metadata = tf.RunMetadata() sess.run(res, options=run_options, run_metadata=run_metadata) #Timeline الآن نقوم بإنشاء كائن من til = timeline.Timeline(run_metadata.step_stats) t = til.generate_chrome_trace_format() #json ثم تخزينه في ملف with open('time.json', 'w') as file: file.write(t)

عندما تقوم بتثبيت tensorflow-gpu جنباً إلى جنب مع نسخة tensorflow السابقة ، ينشأ هذا الخطأ، ولحلها يجب أن تقوم بالتالي: 1.قم بإزالة حزم tensorflow-gpu و tensorflow و tensorflow-base من Anaconda. باستخدام:
conda remove tensorflow-gpu tensorflow tensorflow-base 2. أعد تثبيت تنسرفلو:
conda install tensorflow #if you want to install cpu version conda install tensorflow-gpu # gpu version

لإظهار رسالة flash ، يجب عليك تثبيت وحدة flash في مشروعك باستخدام cmd:
npm install express-session --save npm install cookie-parser --save npm install connect-flash --save الآن عليك إضافة بعض التعليمات البرمجية إلى ملف app.js للوصول إلى هذه الوحدات:
var session = require('express-session'); var cookieParser = require('cookie-parser'); var flash = require('connect-flash'); var app = express(); app.use(cookieParser('secret')); app.use(session({cookie: { maxAge: 60000 }})); app.use(flash()); \\flash الآن إنشاء رسالة req.flash('success', 'Registration successfully'); res.locals.message = req.flash(); \\ لعرضها <% if(locals.message){ %> <div class="alert alert-success" role="alert"> <strong>Well done!</strong> <%=message.success%> </div> <% } %>  

إذا كانت قيمة ترغب في الحصول عليها لكل طلب & نموذج ، فإن استخدام معالج السياق "context processor" يكون أفضل حل كالتالي.. ننشئ ملف Context_processors.py في مجلد التطبيق. ولنفترض أنني أريد الحصول على قيمة ADMIN_PREFIX_VALUE في كل سياق:
from django.conf import settings def _m(request): # إرجاع القيمة التي تريدها كقاموس يمكنك إضافة قيم متعددة هناك return {'ADMIN_MEDIA_URL': settings.ADMIN_MEDIA_PREFIX} #settings.py أضف معالج السياق إلى ملف TEMPLATES = [{ # .. 'OPTIONS': { 'context_processors': [ # .. "your_app.context_processors.admin_media", ], } }] # view في ال RequestContext استخدم #بهذا تلقائياً render shortcut الخاص بك لإضافة معالجات السياق التي تريدها ضمن القالب الذي تريده. يقوم from django.shortcuts import render def admin_media(request): return render(request, "index.html") # وأخيراً ضمن القالب الخاص بك ... <a href="{{ ADMIN_MEDIA_URL }}">path to admin media</a> ... كما أن أبسط طريقة تتجلى باستخدام custom template tag:
from django import template from django.conf import settings register = template.Library() # settings value @register.simple_tag def settings_value(name): return getattr(settings, name, "") # ونستخدم {% settings_value "LANGUAGE_CODE" %}  

في تنسرفلو 1، التعليمة x.assign(1) لاتقوم بتعيين القيمة 1 ل x ولكنه يقوم  بإنشاء tf.Operation (عملية) وبالتالي عليك القيام بتنفيذها بشكل صريح (أي sess.run(x.assign(1))) . * ويمكنك استخدام استدعاء Operation.run أو Session.run لتنفيذ هذه العملية :
my_opration = a.assign(7) s.run(my_opration) a.eval() # ###################### أو ################ my_opration = a.assign(7) my_opration.op.run()` a.eval() # 7 أما في الإصدارات الأحدث من تنسرفلو أصبح بإمكانك استخدام x.assign مباشرةً لتحديث القيمة:
a.assign(5) a.eval() # 5 كما يمكنك استخدام tf.Variable.load(value, session) لإسناد قيمة جديدة لكن فقط في TF1، فقد تم إلغاؤها في TF2:
import tensorflow as tf a = tf.Variable(0) s = tf.Session() s.run(tf.global_variables_initializer()) print(s.run(a)) # 0 a.load(7, s) print(sess.run(a)) # 7

في الرابط التالي يوجد شرح لسبب وجود 3 ملفات (في الإصدارات المختلفة):
أما بالنسبة لاستعادة النموذج فيمكنك القيام بذلك كالتالي:
with tf.Session() as sess: saver = tf.train.import_meta_graph('/tmp/model.ckpt.meta') saver.restore(sess, "/tmp/model.ckpt") بدلاً من ذلك ، يمكنك القيام بالتالي:
# أعد إنشاء نفس المتغيرات بالضبط v1 = tf.Variable(..., name="v1") v2 = tf.Variable(..., name="v2") ... # checkpoint الآن قم بتحميل ال with tf.Session() as sess: saver = tf.train.Saver() saver.restore(sess, "/tmp/model.ckpt")