Ali Haidar Ahmad

لو قمت بعرض نوع البيانات لل history فستجد:
type(history) # keras.callbacks.History وهو يعتبر مرجع ضعيف weakref أو weak rederence (المرجع الضعيف لكائن ما هو المرجع الذي لا يمنع الكائن من أن يتم استعادته بواسطة أداة تجميع البيانات المهملة garbage collector) وفي هذه الحالة لن تتمكن من حفظه بهذه الطريقة. لذا يظهر الخطأ والحل هو بتخزين القاموس الذي يحتويه هذا المرجع من خلال الواصفة history وهي كل مايهمنا حيث تحتوي على المعلومات المطلوبة. أي يصبح الحل:
#history انظر كيف سنحصل على المعلومات المطلوبة من خلال الواصفة history.history """ {'loss': [21.15315055847168, 19.5343074798584], 'mae': [21.15315055847168, 19.5343074798584]} """ import pickle with open('/HistoryDict', 'wb') as f: pickle.dump(history.history, f) history = pickle.load(open('/HistoryDict', "rb")) history """ {'loss': [21.15315055847168, 19.5343074798584], 'mae': [21.15315055847168, 19.5343074798584]} """ كما يمكنك حفظ النتائج بعدة طرق أخرى تجدها في الرابط التالي:
 

بفرض لدينا النموذج التالي، الذي قمنا بتدريبه:
# تحميل الداتا from keras.datasets import boston_housing import keras (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data() # توحيد البيانات mean = train_data.mean(axis=0) train_data -= mean std = train_data.std(axis=0) train_data /= std test_data -= mean test_data /= std from keras import models from keras import layers # بناء النموذج def build_model(): model = models.Sequential() model.add(layers.Dense(64, activation='relu', input_shape=(train_data.shape[1],))) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(1)) model.compile(optimizer='rmsprop', loss="mae", metrics=['mae']) return model # تدريب النموذج model = build_model() # قمنا بتدريب النموذج hisyory=model.fit(train_data, train_targets,epochs=2, batch_size=64) --------------------------------------------------------------------------------------------- """ Epoch 1/2 7/7 [==============================] - 1s 2ms/step - loss: 21.4842 - mae: 21.4842 Epoch 2/2 7/7 [==============================] - 0s 3ms/step - loss: 20.2813 - mae: 20.2813 """ يمكنك حفظ النتائج في ملفات pickle بالشكل التالي:
hisyory.history """ {'loss': [21.15315055847168, 19.5343074798584], 'mae': [21.15315055847168, 19.5343074798584]} """ import pickle with open('/HistoryDict', 'wb') as f: pickle.dump(hisyory.history, f) history = pickle.load(open('/HistoryDict', "rb")) history """ {'loss': [21.15315055847168, 19.5343074798584], 'mae': [21.15315055847168, 19.5343074798584]} """ أو كملفات json:
import json with open('file.json', 'w') as f: json.dump(hisyory.history, f) history1 = json.load(open('file.json')) history1 """ {'loss': [21.15315055847168, 19.5343074798584], 'mae': [21.15315055847168, 19.5343074798584]} """ أو بالشكل التالي:
# حفظها np.save('my_history.npy',hisyory.history) load=np.load('my_history.npy',allow_pickle='TRUE').item() load """ {'loss': [21.15315055847168, 19.5343074798584], 'mae': [21.15315055847168, 19.5343074798584]} """ أو يمكنك تحويلها لداتافريم Dataframe ثم يمكنك حفظها كملفات CSV:
import pandas as pd df = pd.DataFrame(hisyory.history) print(df.head(n=1)) """ loss mae 0 21.153151 21.153151 """ with open('history.csv', mode='w') as f: df.to_csv(f) # إعادة تحميله data = pd.read_csv("history.csv") data.head() """ Unnamed: 0 loss mae 0 0 21.153151 21.153151 1 1 19.534307 19.534307 """  

حسناً سأقترح لك عدة طرق، بدايةً سأقوم بإنشاء تابع لك، تمرر له رقم العمود أو الأعمدة التي تريدها أن تظهر في المصفوفة الجديدة ويعطيك الخرج المطلوب (تمررها على شكل قائمة):
import numpy as np arr = np.random.randint(5, size=(5,3)) print(arr) """ [[4 1 2] [3 2 3] [0 1 4] [4 3 3] [2 3 0]] """ # التابع def make(index,a): a=a.T b=a[index] return b.T # الآن بفرض أنك تريد مصفوفة جديدة من المصفوفة الأصلية مكونة من ثاني و ثالث عمود make([1,2],arr) # الخرج """ array([[1, 2], [2, 3], [1, 4], [3, 3], [3, 0]]) """ # إذا أردنا ثاني عمود فقط make([1],arr) """ array([[1], [2], [1], [3], [3]]) """ حيث اعتمدت على فكرة أخذ منقول المصفوفة ثم اختيار الأعمدة التي أريدها (التي أصبحت تشكل أسطر) ثم بعدها نأخذ المنقول مرة أخرى لتعطي الخرج. وبشكل أكثر سهولة يمكنك استخدام مفهوم الفهرسة والتقطيع في بايثون، بالشكل التالي:
# إذا أردت ثاني عمود arr[:,[1]] """ array([[1], [2], [1], [3], [3]]) """ # ثاني وثالث عمود arr[:,[1,2]] """ array([[1, 2], [2, 3], [1, 4], [3, 3], [3, 0]]) """ وأخيراً، إذا أردت أسطر وأعمدة محددين:
# ثاني وثالث عمود مع أول سطرين فقط arr[:2,1:3] """ array([[1, 2], [2, 3]]) """  

متوسط النسبة المئوية للخطأ المطلق (MAPE)، هي دالة تستخدم لحساب متوسط النسبة المئوية للخطأ المطلق بين y_true و y_pred أي القيم الحقيقية والقيم المتوقعة من قبل النموذج.  وتستخدم مع مهام التوقع، وهي تشابه لحد ما الدالة MAE:
loss = 100 * abs(y_true - y_pred) / y_true ويعتبر هذا المقياس من المقاييس الأكثر شيوعاً المستخدمة مع مهام التنبؤ بالمناخ، ويعمل بشكل أفضل إذا لم تكن البيانات متطرفة (ولاتحوي أصفاراً). ويمكن استدعاؤها من الموديول التالي:
tf.keras.losses.MeanAbsolutePercentageError مثال على استخدامها في كيراس:
import tensorflow as tf y_true = [[2., 1.], [2., 3.]] y_pred = [[1., 1.], [1., 0.]] mape = tf.keras.losses.MeanAbsolutePercentageError() mape(y_true, y_pred).numpy() 50. لاستخدامها في نماذجك يمكنك تمريرها للدالة compile بالشكل التالي:
model.compile( ... loss="MeanAbsolutePercentageError" ) # أو model.compile( ... loss=tf.keras.losses.MeanAbsolutePercentageError() ) مثال عليها أثناء تدريب نموذج لتوقع أسعار المنازل:
# تحميل الداتا from keras.datasets import boston_housing import keras (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data() # توحيد البيانات mean = train_data.mean(axis=0) train_data -= mean std = train_data.std(axis=0) train_data /= std test_data -= mean test_data /= std from keras import models from keras import layers # بناء النموذج def build_model(): model = models.Sequential() model.add(layers.Dense(64, activation='relu', input_shape=(train_data.shape[1],))) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(1)) model.compile(optimizer='adam', loss="MeanAbsolutePercentageError", metrics=['mae']) return model # تدريب النموذج model = build_model() model.fit(train_data, train_targets,epochs=14, batch_size=32) ----------------------------------------------------------------------------------------------- Epoch 11/14 13/13 [==============================] - 0s 3ms/step - loss: 17.9825 - mae: 4.1283 Epoch 12/14 13/13 [==============================] - 0s 2ms/step - loss: 15.7485 - mae: 3.3775 Epoch 13/14 13/13 [==============================] - 0s 2ms/step - loss: 14.7182 - mae: 3.3004 Epoch 14/14 13/13 [==============================] - 0s 2ms/step - loss: 14.9168 - mae: 3.4608 <keras.callbacks.History at 0x7fe5c3a0f810>  

1. تحويل ال tuple إلى قوائم ثم تحويل القائمة إلى مصفوفة، ثم تنفيذ عملية Transpose عليها (المنقول):
tuples = [('a', 2), ("b", 4), ("c", 6)] lists = [list(x) for x in tuples] print(lists) # [['a', 2], ['b', 4], ['c', 6]] arr=np.array(lists) arr.T """ array([['a', 'b', 'c'], ['2', '4', '6']], dtype='<U1') """ 2.بشكل مشابه للطريقة السابقة لكن هنا سوف نستبدل حلقة ال for بتعليمة ال map:
tuples = [('a', 2), ("b", 4), ("c", 6)] lists = list(map(list, tuples)) print(lists) # [['a', 2], ['b', 4], ['c', 6]] arr=np.array(lists) arr.T """ array([['a', 'b', 'c'], ['2', '4', '6']], dtype='<U1') """ 3.تحويلها  إلى قاموس، ثم تحويلها إلى مصفوفة، ثم تنفيذ عملية Transpose عليها (المنقول):
tuples = [('a', 2), ("b", 4), ("c", 6)] dic=dict(tuples) print(dic) # {'a': 2, 'b': 4, 'c': 6} # [['a', 2], ['b', 4], ['c', 6]] arr=np.array(dic).T arr # array({'a': 2, 'b': 4, 'c': 6}, dtype=object) 4. أو بالشكل التالي، حيث نقوم بتحويل القائمة إلى قاموس، ثم نخزن قيمه (القيم وليس المفاتيح)، ثم نحول الخرج ليصبح قائمة ثم نحوله لمصفوفة، وأخيراً نحوله من البعد (,3) إلى البعد (3,1) أي أصبحت مصفوفة ثنائية ثم نقوم باستخراج المفاتيح و نضعهم في مصفوفة (كما في المرحلة السابقة لكن هنا نستخرج المفاتيح ونخزنها) والغاية من ذلك هي لربط  النتائج ووضعها في مصفوقة واحدة، حيث أن المفاتيح للقاموس الذي تم إنتاجه هي ال a  c أما القيم فهي القيم التي تقابلها:
tuples = [('a', 2), ("b", 4), ("c", 6)] values=np.array(list(dict(tuples).values())).reshape(1,-1) # dict_values([2, 4, 6]) keys=np.array(list(dict(tuples).keys())).reshape(1,-1) # dict_keys(['a', 'b', 'c']) np.concatenate((keys, values), axis=0) """ array([['a', 'b', 'c'], ['2', '4', '6']], dtype='<U21') """  

يمكنك القيام بذلك بالشكل التالي في باندا:
df = df.astype(object).where(pd.notnull(df),None) ويمكنك استبدال nan بـ None في مصفوفة numpy الخاصة بك من خلال استخدام التابع np.where حيث نمرر له كوسيط أول القيمة المعادة من تطبيق التابع np.isnan على المصفوفة الخاصة بك، ثم القيمة المراد الاستبدال بها، ثم المصفوفة:
arr = np.array([4, np.nan]) arr = np.where(np.isnan(arr), None, arr) # [4.0 None] print type(arr[1]) #<type 'NoneType'> كما ويمكنك القيام بذلك بسهولة من خلال التابع replace في باندا:
df = df.replace({np.nan: None}) وللتحويل من none ل nan:
import numpy as np x = np.array([3,4,None,55]) x = np.array(x,dtype=float) x #array([ 3., 4., nan, 55.]) # أو x = np.array(x) x.astype(float) #array([ 3., 4., nan, 55.])  

يمكنك القيام بذلك  بالشكل التالي، حيث قمنا بتعريف التابع random.randint الذي يقوم بإنشاء مصفوفة عشوائية من  القيم الصحيحة ب 10 أسطر و 3 أعمدة، بحيث أعلى قيمة فيها هي 5. بعد ذلك قمنا باستخدام نفس التابع لكي يقوم بتوليد أعداد صحيحة أعلى قيمة فيها يساوي 10، وبحجم 3 أي سكون الخرج مصفوفة أحادية البعد، قيم هذه المصفوفة ستمثل فهارس الأسطر التي ستم اختيارها من المصفوفة الجديدة لتشكيل المصفوفة. وأخيراً نقوم باستخدام التعليمة arr[index,:] لعرض المطلوب. حيث  في مثالنا يمكنك أن تلاحظ أن المصفوفة index التي شكلناها تحوي القيم 9 9 4 وبالتالي سنختار الأسطر 9 9 4 من المصفوفة الأصلية لتشكيل المصفوفة الجديدة. كما يجب أن تلاحظ أننا حددنا أكبر قيمة في المصفوفة index بالعدد 10 أي ستكون القيم المولدة أقل من 10 أي من 0 ل 9 وذلك لأن عدد أسطر المصفوفة الأصلية هو 10 أي الفهارس من 0 ل 9 وهذا مهم لكي لانخرج عن حدود المصفوفة وبالتالي لتجنب ظهور أي خطأ.
import numpy as np arr = np.random.randint(5, size=(10,3)) print(arr) """ [[4 1 1] [2 3 2] [1 4 1] [2 2 0] [1 3 3] [3 2 0] [2 0 3] [2 1 2] [4 0 4] [0 2 3]] """ index = np.random.randint(10, size=3) print(index) # [9 9 4] arr[index,:] أو من خلال استخدام التابع np.random.choice ليختار لنا الفهارس بطريقة عشوائية:
indices = np.random.choice(arr.shape[0],3, replace=False) arr[indices] """ array([[3, 2, 0], [2, 3, 2], [2, 2, 0]]) """ arr[np.random.choice(arr.shape[0], 4, replace=False)] """ array([[3, 2, 0], [0, 2, 3], [2, 2, 0], [1, 3, 3]]) """  

يؤدي تكرار مصفوفة كصف باستخدام NumPy إلى ظهور مصفوفة ثنائية الأبعاد جديدة بحيث يكون كل صف هو المصفوفة الأصلية. ينتج عن تكرار مصفوفة كعمود مصفوفة ثنائية الأبعاد جديدة بحيث يكون كل عمود هو المصفوفة الأصلية. أول طريقة لتنفيذ ماتطلبه هي استخدام دالة np.repeat بالشكل التالي، حيث نمرر لها المصفوفة والمحور الذي نريد التكرار عليه وعدد التكرارات:
import numpy as np array_2d = np.array([[1,2,3]]) # سيتم تكرار عناصر المصفوفة على طول الصفوف أي إلى أسفل. np.repeat(array_2d,repeats=3,axis=0) """ array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]) """ arr = np.array([[1],[2],[3]]) # ًفي هذه الحالة، إذا كنت ستستخدم المحور = 1 ، فسيتم تكرار العناصر مع الأعمدة أي أفقيا np.repeat(arr,repeats=3,axis=1) """ array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) """ يمكنك أيضاً استخدام الدالة numpy.tile حيث نمرر لها المصفوفة وعدد مرات التكرار ك tuple أي بالشكل (n, 1)  حيث تمثل n عدد مرات التكرار. والنتيجة ستكون تكرار المصفوفة أحادية الأبعاد الممررة للدالة tile على المحور العمودي. (أي التكرار كأسطر).
an_array = np.array([1,2,3]) # عدد مرات التكرار repeat = 3 np.tile(an_array, (repeat, 1)) """ array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) """ أما لو أردت التكرار كأعمدة كما في الحالة الثانية يمكنك استخدام numpy.transpose بالشكل التالي:
an_array = np.array([[1],[2],[3]]) # عدد مرات التكرار repeat = 3 np.transpose([an_array] * repeat) """ array([[[1, 1, 1], [2, 2, 2], [3, 3, 3]]]) """ وأخيراً يمكنك استخدام التابع np.broadcast_to بحيث نمرر له المصفوفة والأبعاد الجديدة وهو سيتكفل بالتكرار كما في المثال التالي :
an_array = np.array([[1],[2],[3]]) np.broadcast_to(an_array, (3, 3)) """ array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) """ an_array = np.array([1,2,3]) np.broadcast_to(an_array, (3, 3)) """ array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]) """  

pandas: إنها مكتبة مفتوحة المصدر ومرخصة من BSD مكتوبة بلغة Python. توفر Pandas هياكل بيانات وأدوات تحليل بيانات عالية الأداء وسريعة وسهلة الاستخدام لمعالجة البيانات الرقمية والسلاسل الزمنية. تم إنشاء Pandas على مكتبة numpy ومكتوبة بلغات مثل Python و Cython و C. في الباندا ، يمكننا استيراد البيانات من تنسيقات ملفات مختلفة مثل JSON و SQL و Microsoft Excel وما إلى ذلك. مثال: # استيراد المكتبة import pandas as pd # تهيئة وإنشاء قائمة متداخلة age = [['Aman', 95.5, "Male"], ['Sunny', 65.7, "Female"], ['Monty', 85.1, "Male"], ['toni', 75.4, "Male"]] #DataFrame إنشاء df = pd.DataFrame(age, columns=['Name', 'Marks', 'Gender']) Numpy: إنها المكتبة الأساسية للبايثون، وتستخدم لتنفيذ عمليات الحوسبة العلمية. يوفر مصفوفات وأدوات متعددة الأبعاد عالية الأداء للتعامل معها. المصفوفة الرقمية هي شبكة من القيم (من نفس النوع) مفهرسة بواسطة مجموعة من الأعداد الصحيحة الموجبة، والمصفوفات غير المتقاربة سريعة وسهلة الفهم ، وتمنح المستخدمين الصلاحية في إجراء العمليات الحسابية عبر المصفوفات. ويعتمد عليها كثيرٌ من العلماء والباحثين في إجراء العمليات الحسابية الكبيرة والمعقدة على بياناتهم وفي اختباراتهم العلمية. مثال: # استيراد المكتبة import numpy as np # 3-D numpy array using np.array() org_array = np.array([[10, 1, 77], [5, 0, 4]]) عندما يتعين علينا العمل على البيانات الجدولية ، فإننا نفضل وحدة الباندا. عندما يتعين علينا العمل على البيانات العددية ، فإننا نفضل الوحدة النمطية numpy. أدوات الباندا القوية هي Dataframe و Series. في حين أن الأداة القوية لـ numpy هي Arrays. تستهلك الباندا المزيد من الذاكرة. نمباي أكثر فعالية في التعامل مع الذاكرة. تتمتع Pandas بأداء أفضل عندما يكون عدد الصفوف 500 ألف أو أكثر. يتمتع Numpy بأداء أفضل عندما يكون عدد الصفوف 50 ألفًا أو أقل. تعد فهرسة سلاسل الباندا بطيئة جداً مقارنةً بمصفوفات نمباي. تعد الفهرسة في مصفوفات نمباي سريعة جداً. تقدم Pandas كائنات تمثل جدول ثنائي الأبعاد يسمى DataFrame.
Numpy قادر على توفير مصفوفات متعددة الأبعاد. نمباي تقدم لك عمليات سريعة وبكفاءة عالية عند التعامل مع المصفوفات، وإستخدام أمثل للمصادر عند المعالجة. وتعتمد عليها كثير من المكتبات الأخرى مثل Pandas و theanets وغيرهما. يوفر باندا وظائف كثيرة مثل: data alignment و NA-friendly statistics و groupby و merge و join والعديد من الأدوات الأخرى المريحة، التي أصبحت شائعة جداً في السنوات الأخيرة في التطبيقات المالية. وأيضاً في تعلم الآلة. وتقدم المكتبة ما يسمى ب إطار البيانات (Data Frame) والذي يسهل من إستيراد البيانات والتعامل معها بسهولة. و تسهل المكتبة عمليات (Data Preprocessing ) مثل تنظيف البيانات، ومعالجة القيم الفارغة فيها، وإجراء العمليات الإستكشافية على البيانات. وتسهل دمج البيانات ببعضها أو تجزيئها إلى إطارات متعددة.
أما بالنسبة لمكتبة SciPy فبشكل مختصر مكتبة (SciPy) هي نفس مكتبة (NumPy) تقريباً وهي أيضاً من بين المكتبات الاساسية للحسابات العلمية وخوارزميات الرياضيات والدوال المعقدة. ولكنها مبنية كأمتداد لمكتبة (NumPy) مما يعني أنهما يستخدمان سوية في أغلب الاحيان. تأتي هذه المكتبة على رأس هرم مكتبات علم البيانات بالبايثون ، وتخدم جانب تحليل البيانات و تعليم الالة بشكل قوي، ولا تقتصر على ذلك، حيث تقدم إمكانات هائلة في مجال معالجة الإشارات ومعالجة الصور والعمليات الحسابية المعقدة. تتكون وتعتمد مكتبة Scipy على خليط من المكتبات المشهورة مثل Numpy, Pandas, Matplotlib, Sympy, IPython وغيرها. تُقدم المكتبة مجموعة واسعة من الخوارزميات والحزم العلمية التي لها علاقة بالأخص بالعمليات الرياضية، الدوال الإحصائية وتعليم الألة. ومن ميزاتها أنها تقدم دوال واسعة في مجال الاحتمالات والإحصاء عبر موديول stats. وتدعم عمليات الجبر الخطي و Fourier transform. وتقدم المكتبة مجموعة من الدوال الخاصة بمعالجة المصفوفات متعددة الأبعاد لمعالجة الصور. وإجراء التحليل المكاني (Spatial Analysis) عبر مجموعة من الخوارزميات المتخصصة الموجودة في موديول spatial.

في النسخ الحديثة تم استبدال الموديول visualize_util  ب vis_utils وتم تغيير اسم التابع من plot إلى plot_mode وبالتالي يجب استيرادها بالشكل التالي:
from keras.utils.vis_utils import plot_model أو من خلال وحدة كيراس المضمنة في تنسرفلو (بدءاً من نسخة تنسرفلو 2.0) كالتالي:
from tensorflow.keras.utils import plot_model  

أولاً np.mean يحسب دائماً متوسطاً حسابياً، ولديه بعض الخيارات الإضافية للإدخال والإخراج (على سبيل المثال ، أنواع البيانات التي يجب استخدامها ، ومكان وضع النتيجة.
numpy.mean(a, axis=None, dtype=None, out=None) أمثلة:
a = np.array([[1, 2], [3, 4]]) np.mean(a) #2.5 np.mean(a, axis=0) #array([2., 3.]) np.mean(a, axis=1) #array([1.5, 3.5]) حيث أن الوسيط الأول هو المصفوفة، والثاني هي المحاور أو المحور الذي سيتم حساب المتوسط عليه.و الافتراضي none يعني حساب متوسط المصفوفة المسطحة أي كامل المصفوفة. أما الوسيط الثالث فهو النمط المستخدم في حساب المتوسط. بالنسبة لمدخلات الأعداد الصحيحة ، الافتراضي هو ؛ float64 ولمدخلات الفاصلة العائمة، وهو نفس نوع الإدخال dtype. أما الوسيط التالي فهو مصفوفة إخراج بديلة لوضع النتيجة فيها.
ثانياً np.average يمكن حساب المتوسط الموزون إذا قمنا بتزويده بأوزان المعلمات.
numpy.average(a, axis=None, weights=None) أول وثاني وسيط كما في التابع السابق لكن الوسيط الثالث هو مصفوفة الأوزان المرتبطة بالقيم الموجودة في المصفوفة. كل قيمة في a تساهم في المتوسط وفقاً للوزن المرتبط بها. يمكن أن تكون مصفوفة الأوزان إما 1-D (وفي هذه الحالة يجب أن يكون طولها بحجم a على طول المحور المحدد) أو من نفس الشكل مثل a. إذا كانت الأوزان = None، فسيتم افتراض أن جميع البيانات الموجودة في a لها نفس الوزن. أمثلة:
data = np.arange(1, 5) np.average(data) #2.5 np.average(np.arange(1, 11), weights=np.arange(10, 0, -1)) #4.0 data = np.arange(6).reshape((3,2)) """ array([[0, 1], [2, 3], [4, 5]]) """ np.average(data, axis=1, weights=[1./4, 3./4]) #array([0.75, 2.75, 4.75]) np.average(data, weights=[1./4, 3./4]) # TypeError: Axis must be specified when shapes of a and weights differ.  

يمكن إنشاء دالة خسارة مخصصة عن طريق تعريف الدلة التي تريد استخدامها، بحيث يجب أن تأخذ هذه الدالة القيم الحقيقية والقيم المتوقعة ،وأن تعيد الدالة قيم الكلفة للبيانات الممررة. وأخيراً يكون بعد ذلك بإمكانك تمرير التابع الخاص بك في مرحلة الترجمة compile. ويجب أن تكون حريصاً في النقاط التالية: 
1. تأخذ دالة الخسارة وسيطتين فقط ، وهما القيمة المستهدفة (y_true) والقيمة المتوقعة (y_pred). لأنه من أجل قياس الخطأ في التنبؤ (الخسارة) نحتاج إلى هاتين القيمتين. يتم تمرير هذه الوسائط من النموذج نفسه في وقت ملاءمة البيانات. 2. يجب أن تستفيد دالة الخسارة من قيمة y_pred أثناء حساب الخسارة ، إذا لم تقم بذلك ، فستحصل على خطأ ولن يتم حساب ال Gradients.ا 4.  يكون البعد الأول للوسيطتين y_true و y_pred دائماً هو نفسه حجم الدفعة (حجم الباتش Batch_size). على سبيل المثال، إذا كنت تلائم البيانات بحجم دفعة 64، وكانت شبكتك العصبية تحتوي على 10خلايا إخراج، فستكون أبعاد y_pred  هي (64,10) . لأنه سيكون هناك 64 قيمة كخرج للنموذج، ولكل منها 10 قيم. (64 حجم الباتش ولدينا 10 خلايا في طبقة الخرج، هذا يعني أنه سيكون لدينا في كل مرة 64 عينة نحسب لها 10 نواتج وكل ناتج نقارنه بالقيمة الحقيقية وفق دالة التكلفة). 5. يجب أن تقوم دالة الخسارة دائماً بإرجاع متجه بطول batch_size. لأنه يتعين عليك إرجاع خسارة لكل نقطة بيانات أي لكل عينة.
يمكنك تعريفها بالشكل التالي:
def loss(y_true, y_pred): # نكتب الدالة هنا ولاننسى أن تكون متعلقة بالقيم المتوقعة return loss # بعدها يمكننا تمريرها للنموذج بالشكل التالي model.compile( loss=custom_loss, ) بشكل عام يفضل استخدام keras.backend أثناء بناء دالتك لتحنب حدوث أخطاء (يمكنك استخدام نمباي لامشكلة، لكن يفضل استخدام backend ). في المثال التالي سأقوم ببناء دالة تكلفة وأعطي وزن أيضاً للإخراج. فرضاً لدينا مهمة توقع والخرج هو قيمتين [x1, x2] ونريد إعطاء x2 أهمية أكبر عند حساب التكلفة:
from keras import backend def custom_mse(y_true, y_pred): # حساب مربع الفرق بين القيم الحقيقية والمتوقعة loss = backend.square(y_pred - y_true) # (batch_size, 2) # ضرب النواتج بقيم الأوزان التي نريدها حيث هنا أعطينا أهمية أكبر للمخرج الثاني loss = loss * [0.3, 0.7] # (batch_size, 2) # حساب مجموع الأخطاء loss = backend.sum(loss, axis=1) # (batch_size,) return loss

ألصورة التالية توضح مفهوم ال Tokenaization:


توفر لك كيراس القيام بذلك بسهولة عن طريق الأداة Tokenizer من الموديول tf.keras.preprocessing.text.Tokenizer حيث تمكنك هذه الأداة من ترميز النص الخاص بك ليصبح عبارة عن سلسلة من الأعداد الصحيحة، بحيث نقوم بتمرير كامل مجموعة البيانات الخاصة بنا له، ثم يقوم بملائمتها fitting ، وتتضمن عملية الملائمة هذه بعض عمليات الفلترة على البيانات النصية ثم تقسيم كل نص (عينة) إلى الكلمات المكون منها ثم إنشاء قاموس يحوي كل الكلمات الفريدة التي وجدها مع عدد صحيح يمثلها (كل كلمة يعبر عنها بعدد صحيح)، وتسمى "Tokens".  ثم بعد ذلك يمكننا تحول كل عينة من بياناتنا إلى الترميز العددي من خلال التابع texts_to_sequences. لكن أولاً دعنا نستعرض شكل هذه الأداة:
tf.keras.preprocessing.text.Tokenizer( num_words=None, filters='!"#$%&()*+,-./:;<=>?@[\\]^_`{|}~\t\n', lower=True, split=" ", char_level=False, oov_token=None, document_count=0, **kwargs) الوسيط الأول يعبر عن العدد الأعظمي للكلمات المرغوب بحفظها في القاموس، حيث كما ذكرنا فإن هذه الأداة تقوم بإنشاء قاموس يحوي كامل الكلمات التي وجدها مع عدد صحيح يمثل كل كلمة، وبالتالي قد يحتوي هذا القاموس على مئات الآلاف من الكلمات الفريدة لكن لاتبقى كلها حيث يتم اختيار أهم 10 آلاف كلمة كحد أقصى من القاموس حسب أهميتها (الأهمية تعتمد على عدد مرات ظهور الكلمة في البيانات) ويتم الاختفاظ بها أما باقي الكلمات يتم تجاهلها. لكن يمكننا تغيير هذا الرقم من خلال الوسيط num_words فافتراضياً يأخذ القيمة 10 آلاف، لكن يمكننا وضع قيمة أخرى، مثلاً 75000 أي الاحتفاظ بأهم 75 ألف كلمة. أما الوسيط الثاني فهو الفلتر الذي سيتم تطبيقه على البيانات ويتضمن حذف علامات الترقيم والمسافات الفارغة والرموز (يمكنك تحديد ماتريد، لكن إذا تركت علامات الترقيم مثلاً، فسيتم ترميزها أي إسناد عدد صحيح يمثلها)، أما الوسيط الثالث فهو يحدد فيما إذا أردت تغيير حالة أحرف النصوص إلى  أحرف صغيرة أم لا (يفضل القيام بذلك لأنه مثلاً إذا  وجد كلمة Good و good سيتم اعتبارهما كلمتين مختلفتين وبالتالي يعطيهما ترميز مختلف)، أما الوسيط split فهو يمثل الرمز الذي سيتم تقسيم كل نص على أساسه إلى كلمات منفصلة.  والوسيط الخامس لتحديد مستوى التقسيم وفي حالتنا نضعه على False (عند وضعه على True ستتم عملية التقسيم على مستوى الأحرف وليس الكلمات أي مثلاً سيتم تقسيم الكلمة  Win إلى W و i و n وهنا لانحتاجه)، أما الوسيط السادس فنحتاجه عند القيام بعملية texts_to_sequences وذلك لوضع عدد صحيح يمثل الكلمات التي لم يجدها في القاموس (غير موجودة لديه، حيث كما ذكرنا فهو يحتفظ بعدد محدد من الكلمات وبالتالي قد يستقبل كلمة غير معرَفة لديه وغالباً نضعه على None أي الحالة الافتراضية) . أما التوابع التي نحتاجها فهي التابع fit_on_texts للقيام بعملية ال fitting حيث نمرر له كامل مجموعة البيانات، والتابع texts_to_sequences للقيام بعملية التحويل حيث نمرر له العينة أو مجموعة العينات (البيانات) المراد تطبيق التحويل عليها دفعة واحدة كما سنعرض في المثال التالي، وأيضاً هناك بعض الواصفات التي يمكننا أن نستعرض من خلالها محتويات القاموس مثل word_counts الذي يعرض لك قاموس ال Tokens مع عدد مرات ظهور كل Tokens، والواصفة document_count يرد لك عدد العينات (المستندات النصية) التي قام بترميزها. و word_index الذي يرد ال Tokens والعدد الصحيح الذي يمثلها يحيث يكون عبارة عن قاموس المفاتيح فيه هي الكلمات والقيم فيه هي العدد الصحيح الذي يمثلها. word_docs  يرد كل ال Tokens وتردد كل منها. مثال:
from keras.preprocessing.text import Tokenizer #إنشاء غرض t = Tokenizer() text = ['assign integers to characters', 'Machine Learning', 'assign', 'Machine Learning'] # الملاءمة t.fit_on_texts(text) # عرض المعلومات print("Count of characters:",t.word_counts) print("Length of text:",t.document_count) print("Character index",t.word_index) print("Frequency of characters:",t.word_docs) # التحويل s = t.texts_to_sequences(text) print(s) """ Count of characters: OrderedDict([('assign', 2), ('integers', 1), ('to', 1), ('characters', 1), ('machine', 2), ('learning', 2)]) Length of text: 4 Character index {'assign': 1, 'machine': 2, 'learning': 3, 'integers': 4, 'to': 5, 'characters': 6} Frequency of characters: defaultdict(<class 'int'>, {'assign': 2, 'integers': 1, 'to': 1, 'characters': 1, 'machine': 2, 'learning': 2}) [[1, 4, 5, 6], [2, 3], [1], [2, 3]] """ وإليك المثال العملي لاستخدامها أثناء تحضير البيانات قبل بناء نموذج لتصنيف المشاعر حيث تكون البيانات نصية ونريد إدخالها في الشبكة العصبية للتدريب وبالتالي يجب أولاً القيام بعملية Tokenizaton كالتالي:
from keras.preprocessing.text import Tokenizer from keras.preprocessing.sequence import pad_sequences import numpy as np maxlen = 100 training_samples = 200 validation_samples = 10000 max_words = 10000 tokenizer = Tokenizer(num_words=max_words) tokenizer.fit_on_texts(texts) sequences = tokenizer.texts_to_sequences(texts) word_index = tokenizer.word_index print('Found %s unique tokens.' % len(word_index)) data = pad_sequences(sequences, maxlen=maxlen) labels = np.asarray(labels) print('Shape of data tensor:', data.shape) print('Shape of label tensor:', labels.shape) indices = np.arange(data.shape[0]) np.random.shuffle(indices) data = data[indices] labels = labels[indices] x_train = data[:training_samples] y_train = labels[:training_samples] x_val = data[training_samples: training_samples + validation_samples] y_val = labels[training_samples: training_samples + validation_samples] glove_dir = '/Users/fchollet/Downloads/glove.6B' embeddings_index = {} f = open(os.path.join(glove_dir, 'glove.6B.100d.txt')) for line in f: values = line.split() word = values[0] coefs = np.asarray(values[1:], dtype='float32') embeddings_index[word] = coefs f.close() print('Found %s word vectors.' % len(embeddings_index)) embedding_dim = 100 embedding_matrix = np.zeros((max_words, embedding_dim)) for word, i in word_index.items(): if i < max_words: embedding_vector = embeddings_index.get(word) if embedding_vector is not None: embedding_matrix[i] = embedding_vector from keras.models import Sequential from keras.layers import Embedding, Flatten, Dense model = Sequential() model.add(Embedding(max_words, embedding_dim, input_length=maxlen)) model.add(Flatten()) model.add(Dense(32, activation='relu')) model.add(Dense(1, activation='sigmoid')) model.layers[0].set_weights([embedding_matrix]) model.layers[0].trainable = False model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_val, y_val))  

إذا كنت تستخدم واجهة  Keras المنفصلة، يجب عليك تحميل الحزمة التالية وذلك في حال كانت النسخة الخاصة بك أقل من 2.3:
pip install keras-metrics ثم بعد ذلك يمكنك استخدام هذه المعايير من هذه الحزمة كالتالي:
import keras_metrics model.compile( ... metrics=[keras_metrics.precision(), keras_metrics.recall()]) إذا كنت تستخدم نسخة كيراس الأحدث فيمكنك القيام بذلك من خلال الموديول keras.metrics:
model.compile( ... metrics=[keras.metrics.Precision(), keras.metrics.Recall()]) أما إذا كنت تستخدم النسخة المدمجة مع تنسرفلو، فيمكنك القيام بذلك بشكل مباشر من خلال الموديول tf.keras.metrics:
import tensorflow as tf model.compile( ... metrics=[tf.keras.metrics.Precision(), tf.keras.metrics.Recall()]) أمثلة:
m = tf.keras.metrics.Precision() m.update_state([0, 1, 1, 1], [1, 0, 1, 1]) m.result().numpy() #0.6667 m.reset_state() m.update_state([0, 1, 1, 1], [0, 1, 1, 1]) m.result().numpy() #1.0 m = tf.keras.metrics.Recall() m.reset_state() m.update_state([0, 1, 1, 1], [0, 1, 1, 1]) m.result().numpy() #1.0 التطبيق على نموذج:
from keras import layers from keras import models model = models.Sequential() model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.Flatten()) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(10, activation='softmax')) from keras.datasets import mnist import keras import tensorflow as tf from tensorflow.keras.utils import to_categorical (train_images, train_labels), (test_images, test_labels) = mnist.load_data() train_images = train_images.reshape((60000, 28, 28, 1)) train_images = train_images.astype('float32') / 255 test_images = test_images.reshape((10000, 28, 28, 1)) test_images = test_images.astype('float32') / 255 train_labels = to_categorical(train_labels) test_labels = to_categorical(test_labels) model.compile(optimizer='rmsprop', loss="CategoricalCrossentropy", metrics=[tf.keras.metrics.Precision(), tf.keras.metrics.Recall()]) model.fit(train_images, train_labels, epochs=2, batch_size=512) ---------------------------------------------------------------------------------------- Epoch 1/2 118/118 [==============================] - 46s 374ms/step - loss: 0.9313 - precision_5: 0.7849 - recall_4: 0.3362 Epoch 2/2 118/118 [==============================] - 44s 375ms/step - loss: 0.1283 - precision_5: 0.9423 - recall_4: 0.8137 <keras.callbacks.History at 0x7f5e17641950> ولحسابهم على بيانات الاختبار:
from keras import backend as K def recall(y_true, y_pred): tp = K.sum(K.round(K.clip(y_true * y_pred, 0, 1))) p = K.sum(K.round(K.clip(y_true, 0, 1))) result = tp / (p + K.epsilon()) return result.numpy() def precision(y_true, y_pred): tp = K.sum(K.round(K.clip(y_true * y_pred, 0, 1))) p = K.sum(K.round(K.clip(y_pred, 0, 1))) result = tp / (p + K.epsilon()) return result.numpy() e=precision_m(train_labels,model.predict(train_images))  

يمكنك استخدام الدالة numpy.flip عن طريق تمرير الدالة argsort لها حيث سترد لك ال indexes للقيم مرتبة بترتيب تنازلي بعد أن يتم فرزها تصاعدياً باستخدام  argsort حيث تقوم هذه الدالة بعكس ترتيب العناصر :
import numpy as np a = np.array([2, 9, 7, 10, 5, 3]) n=3 ids = np.flip(np.argsort(a)) print(ids[0:n]) #[3 1 2] نفس الفكرة باستخدام np.flipud:
import numpy as np a = np.array([2, 9, 7, 10, 5, 3]) n=3 ids = np.flipud(np.argsort(a)) print(ids[0:n]) #[3 1 2] أو يمكنك القيام بعكسها بإحدى الأشكال التالية:
# نضرب المصفوفة بسالب وبالتالي يصبح الأصغر أكبر وبالتالي نحصل على الفهرس المطلوب np.argsort(-1*a)[:3] #- كما ويمكن استخدام المعامل # أي بشكل مشابه للطريقة السابقة (-a).argsort()[:3] # أو بالطريقة التقليدية عن طريق أخذ آخر 3 عناصر a.argsort()[::-1][:3] وكمقارنة:
%timeit np.flipud(np.argsort(a))[0:3] %timeit np.flip(np.argsort(a))[0:3] %timeit np.argsort(-1*a)[:3] %timeit (-a).argsort()[:3] %timeit a.argsort()[::-1][:3] 5.14 µs ± 211 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 5.29 µs ± 337 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 4.57 µs ± 127 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 1.97 µs ± 288 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 1.86 µs ± 251 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) # الطريقة الأخيرة أفضل  

يمكنك القيام بذلك بشكل يدوي:
import numpy as np A = np.random.randint(low=0,high=255, size=(2, 4)).astype(float) A """ array([[166., 246., 37., 195.], [ 63., 33., 189., 200.]]) """ th=127 A[A > th] = 255.0 A """ array([[255., 255., 37., 255.], [ 63., 33., 255., 255.]]) """ كما ويمكنك استخدام التابع np.putmask حيث نمرر له المصفوفة والعتبة والقيمة المراد الاستبدال بها:
A = np.random.randint(low=0,high=255, size=(2, 4)).astype(float) """ array([[ 62., 23., 218., 205.], [197., 254., 149., 32.]]) """ # تحديد العتبة T=127 np.putmask(A, A>=T, 255.0) """ array([[ 62., 23., 255., 255.], [255., 255., 255., 32.]]) """ أو من خلال np.place حيث نمرر له المصفوفة، ثم العتبة كما في المثال، ثم القيمة المراد التحويل لها :
A=np.array([[ 62., 23., 218., 205.], [197., 254., 149., 32.]]) np.place(A, A >=127, 255) """ array([[ 62., 23., 255., 255.], [255., 255., 255., 32.]]) """ أو من خلال np.where:
A=np.array([[ 62., 23., 218., 205.], [197., 254., 149., 32.]]) np.where(A > 127, 255,A) """ array([[ 62., 23., 255., 255.], [255., 255., 255., 32.]]) """ كمقارنة:
%timeit np.place(A, A >=127, 255) %timeit np.putmask(A, A>127, 255) %timeit np.where(A > 127, 255,A) 3.44 µs ± 197 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 3.03 µs ± 162 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 4.84 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each) # قريبتان من بعضهما لكن الأولى أفضل  

يمكنك استخدام numpy.ndarray.size. فعن طريق الوصول إلى عدد العناصر في numpy.ndarray باستخدام numpy.ndarray.size. يمكنك تحديد فيما إذا كانت المصفوفة فارغة أم لا حيث، إذا كان عدد العناصر في المصفوفة يساوي 0 ، فإن المصفوفة فارغة:
import numpy as np empty_array = np.array([]) is_empty = empty_array.size == 0 is_empty # True ################################ empty_array = np.array([1,2]) is_empty = empty_array.size == 0 is_empty # False حسناً قد تظهر لنا مشكلة عندما يتم تعريف المصفوفة الفارغة بالشكل  np.array(None) حيث أن ناتج تطبيق size سيكون 1، لذا لحل المشكلة:
import numpy as np empty_array = np.array(None) is_empty = False if empty_array.size and empty_array.ndim else True is_empty # True ########################## import numpy as np empty_array = np.array([]) is_empty = False if empty_array.size and empty_array.ndim else True is_empty # True ######################### import numpy as np empty_array = np.array([1]) is_empty = False if empty_array.size and empty_array.ndim else True is_empty # False ويمكنك كتابة التابع التالي الذي يشمل كل ماسبق:
def elements(array): return False if array.ndim and array.size else True elements(np.array([1])) #False elements(np.array([])) # True elements(np.array(None)) # True كما ويمكنك استخدام الدالة np.any، لكن القيد على هذه الوظيفة هو أنها لا تعمل إذا كانت المصفوفة تحتوي على القيمة 0 فيها.
import numpy as np arr = np.array([]) flag = not np.any(arr) if flag: print('empty') else: print('not empty') # empty ############################# arr = np.array(None) flag = not np.any(arr) if flag: print('empty') else: print('not empty') # empty ############################ arr = np.array([1]) flag = not np.any(arr) if flag: print('empty') else: print('not empty') # not empty أو من خلال تحويلها لقائمة:
import numpy as np arr = np.array([1]) if len(arr.tolist()) == 0: print("Empty") else: print("Not") قمنا أولاً بتحويل المصفوفة إلى قائمة باستخدام طريقة tolist (). ثم تحققنا من حجم القائمة باستخدام طريقة len () للتحقق مما إذا كانت المصفوفة فارغة.، لكن في حال تم تعريف المصفوفة من خلال None فسيظهر خطأ لذا لحل المشكلة قمت بتعريف التابع التالي:
def test(a): try: if len(a.tolist()) == 0: return "Empty" else: return "Not" except: return "Empty" test(np.array([1])) # 'Not' test(np.array([])) # 'Empty' test(np.array(None)) # 'Empty' وأخيراً من خلال التبع shape:
import numpy as np a = np.array([]) if a.shape[0] == 0: print("Empty") وذلك من خلال التحقق مما إذا كان عدد العناصر في المحور 0 ، أي الصف ، صفراً أم لا.

الخطأ هنا من المكان الذي تستورد فيه دالة التكلفة CategoricalCrossentropy، فهذه الدالة يمكن استخدامها كدالة تكلفة وكمعيار لقياس الدقة. ففي حالة كنت تريد استخدامها كدالة تكلفة يجب عليك استيرادها من الموديول losses أما إذا أردت استخدامها كمعيار فعيلك استيرادها من الموديول metrices أي يصبح نموذجك كالتالي:
from keras import layers from keras import models model = models.Sequential() model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.Flatten()) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(10, activation='softmax')) from keras.datasets import mnist import keras from tensorflow.keras.utils import to_categorical (train_images, train_labels), (test_images, test_labels) = mnist.load_data() train_images = train_images.reshape((60000, 28, 28, 1)) train_images = train_images.astype('float32') / 255 test_images = test_images.reshape((10000, 28, 28, 1)) test_images = test_images.astype('float32') / 255 train_labels = to_categorical(train_labels) test_labels = to_categorical(test_labels) model.compile(optimizer='rmsprop', loss=keras.losses.CategoricalCrossentropy(), metrics=["acc"]) model.fit(train_images, train_labels, epochs=5, batch_size=64) test_loss, test_acc = model.evaluate(test_images, test_labels) # 99% حيث أنه أعطاك خطأ يعبر عن عدم قدرته على حساب المشتقات وذلك لأنه لم يتعرف على دالة التكلفة التي قمت بتمريرها.

يمكننا استخدام الدالة empty لإنشاء مصفوفة ثم القيام بتعبئتها بالقيمة المطلوبة من خلال التابع fill كما يلي:
def fill(n): arr = np.empty(n) return arr.fill(np.nan) fill(5) # array([nan, nan, nan, nan, nan]) def fill(n): arr = np.empty(n) arr.fill(np.nan) return arr print(fill((3,2))) """ [[nan nan] [nan nan] [nan nan]] """ أو يمكنك أن تقوم يتعبئتها بشكل يدوي:
def c(n): a = np.empty(n) a[:] = np.nan return a print(c((3,2))) """ [[nan nan] [nan nan] [nan nan]] """ وكطريقة سهلة يمكنك استخدام التابع full بحيث نمرر له أبعاد المصفوفة والقيمة المراد تعبئتها:
def full(n): return numpy.full(n, np.nan) print(c((3,2))) """ [[nan nan] [nan nan] [nan nan]] """ أو من خلال التابع التالي حيث سنعتمد على مفهوم القوائم ثم تحويلها لمصفوفة نمباي:
def list(n,row,col): return np.array(n * [np.nan]).reshape(-1,col) print(list(12,3,4)) """ [[nan nan nan nan] [nan nan nan nan] [nan nan nan nan]] """ لكن هنا نمرر عدد عناصر المصفوفة المطلوبة وعدد أسطر وأعمدة المصفوفة المطلوبة. ويمكنك أيضاً تنفيذ ماتريده بالشكل التالي:
np.nan * np.zeros(shape=(3,2)) """ array([[nan, nan], [nan, nan], [nan, nan]]) """ كما ويمكنك من خلال الدالةtile حيث نمرر لها القيمة ثم الأبعاد كما في المثال التالي :
np.tile(np.nan, (2, 3)) """ array([[nan, nan, nan], [nan, nan, nan]]) """ وبشكل عام فإن أسرع طريقة هي استخدام الدالة fill.

أولاً يجب أن نفهم المشكلة. ال unit vector أو متجه الوحدة هو متجه طويلته (magnitude) تساوي ال 1. وبالتالي فإن الشعاع التالي لايمثل متجه وحدة:
import numpy as np # تعريف الشعاع التالي v = np.array([1,3]) # حساب الطويلة np.linalg.norm(v) #3.1622776601683795 # إذاً ليس متجه وحدة حيث أن التابع np.linalg.norm(x) يقوم بحساب الطويلة للشعاع. الآن إذا أردنا أن نقوم بتحويل هذا الشعاع إلى متجه وحدة فيجب أن نقوم بعملية normalizing. رياضياً فإنه لتحويل أي شعاع إلى شعاع وحدة يجب أن نقوم بقسمة جميع عناصره على طويلته، أي لتحويل الشعاع السابق يجب أن نقوم بقسمة قيمه على 3.16227766.
import numpy as np v = np.array([1,3]) magnitude =np.linalg.norm(v) # نقسم كل عنصر على الطويلة v=v/magnitude # نختبر إذا أصبح متجه وحدة np.linalg.norm(v) # 1.0 # نجحنا حسناً إذا أردت أن لاتستخدم np.linalg.norm(v) يمكنك استخدام الصيغة التالية، فكما نعلم أن الطويلة هي الجذر التربيعي لمجموع مربعات قيم الشعاع:
import numpy as np v = np.array([1,3,5,6,33]) magnitude =np.sqrt(np.sum(v**2)) # نقسم كل عنصر على الطويلة v=v/magnitude # نختبر إذا أصبح متجه وحدة np.linalg.norm(v) # 1.0 # نجحنا كما ويمكنك استخدام مكتبة Sklearn حيث تحتوي على طرق فعالة متاحة للمعالجة المسبقة للبيانات وأدوات التعلم الآلي الأخرى. عادةً ما يستخدم التابع normalize في هذه المكتبة مع المصفوفات ثنائية الأبعاد وتوفر خيار تسوية L1 و L2. سنستخدم في الكود التالي هذه التابع مع مصفوفة 1D حيث سنقوم باستخدام الدالة ravel لتسطيح المصفوفة :
import numpy as np from sklearn.preprocessing import normalize v = np.array([1,3,5,6,33]) v = normalize(v[:,np.newaxis], axis=0).ravel() # نختبر إذا أصبح متجه وحدة np.linalg.norm(v) # 1.0 # نجحنا ,وأخيراً يمكنك استخدام الدالة الجاهزة لتحويل الشعاع إلى شعاع  وحدة بشكل مباشر من خلال المكتبة transformations:
# لتحميلها : pip install transformations import numpy as np import transformations as trafo v = np.array([1,3,5,6,33]) unit_v = trafo.unit_vector(data, axis=1) # نختبر إذا أصبح متجه وحدة np.linalg.norm(unit_v) # 1.0  

الطريقة الوحيدة في نمباي من خلال التابع percentile :
import numpy as np arr = np.array([1,2,3,4,5]) # نريد القيمة الأكبر من نصف عناصر المصفوفة per = np.percentile(arr, 50) # 3.0 # القيمة الأكبر من 90 بالمئة من عناصر المصفوفة np.percentile(arr, 90) # 4.6 np.percentile(arr, 100) # 5.0 np.percentile(arr, 0) # 1.0 حيث نمرر له المصفوفة والنسبة المئوية التي نريده أن يرد لنا القيمة الموافقة لها. وإذا أردت أن يتم تقريب قيم الخرج لأقرب قيمة. أي مثلاً بدلاً من 4.6 تريد 4 أو 5 فيمكنك القيام بذلك كالتالي:
import numpy as np arr = np.array([1,2,3,4,6]) np.percentile(arr, 90, interpolation='lower') # 4 # التقريب للأعلى np.percentile(arr, 90, interpolation='higher') # 6 مثال آخر:
a = np.array([[10, 7, 4], [3, 2, 1]]) """ array([[10, 7, 4], [ 3, 2, 1]]) """ np.percentile(a, 50) # 3.5 np.percentile(a, 50, axis=0) # array([6.5, 4.5, 2.5]) np.percentile(a, 50, axis=1) # array([7., 2.]) np.percentile(a, 50, axis=0, out=out) """ array([6.5, 4.5, 2.5]) """ np.percentile(a, 50, axis=1, keepdims=True) """ array([[7.], [2.]]) """ حيث أن  الوسيط axis يمثل المحور أو المحاور التي سيتم حساب النسب المئوية على طولها. الافتراضي هو حساب النسب المئوية على طول نسخة مسطحة من المصفوفة.  أما الوسيط out فيمثل مصفوفة إخراج بديلة لوضع النتيجة فيها. يجب أن يكون له نفس الشكل وطول المخزن المؤقت للإخراج المتوقع ، ولكن سيتم إرسال نوع (الإخراج) إذا لزم الأمر.
ويمكنك من خلال التابع التالي القيام بذلك حيث سنستعين بالمكتبة الرياضية في بايثون:
import numpy as np arr = np.array([1,2,3,4,5]) import math def per(data, perc: int): return sorted(data)[int(math.ceil((len(data) * perc) / 100)) - 1] per(arr,50) # 3 per(arr,90) # 5 # لاحظ أنه لم يعطي 4.6 per(arr,92) # 5 لكن هنا كما تلاحظ قام بعملية تقريب بحيث تكون القيمة ضمن المصفوفة أي لن يحتسب مجالات القيم. ويمكنك أيضاً القيام بذلك من خلال التابع التالي:
import numpy as np arr = np.array([1,2,3,4,5]) def per(N, P): n = int(round(P * len(N) + 0.5)) return N[n-1] per(arr,0.5) # 3 per(arr,0.9) # 5  

يخبرك الخطأ بأن أبعاد بيانات التدريب لديك (الدخل) هي (50000, 32, 32, 3) بينما أنت قمت بتعريف النموذج على أن تستقبل طبقة الدخل الخاصة به input_shape أبعاد من الشكل (3, 32, 32)  أي input_shape=(3, 32, 32) وبالتالي ظهر الخطأ نتيجة عدم توافق الأبعاد. أي أن شكل الإدخال المتوقع والبيانات المعطاة مختلفين. ولحل المشكلة يجب أن تقوم بتعديل أبعاد طبقة الدخل في نموذجك أي input_shape=(32, 32, 3) أو أن تقوم بتغيير أبعاد الدخل يحيث يتوافق مع طبقة الدخل في نموذجك:
x_train = x_train.transpose(0,3,1,2) x_test = x_test.transpose(0,3,1,2)  

تقوم هذه الدالة بحساب مدى دقة النموذج، وتستخدم مع مهام التصنيف، عندما يكون الترميز الخاص بال label هو One-Hot وترد هذه الدالة قيمة عشرية بين 0 و 1 بحيث كلما اقتربت القيمة من 1 كانت دقة النموذج أعلى. وتقوم هذه الدالة بحساب عدد المرات التي قام فيها نموذجنا بتوقع القيم بشكل صحيح (عدد مرات الإصابة في التنبؤ أو بمعنى آخر عدد مرات التطابق) وتقسمها على عدد التوقعات الكلية (الصحيحة والخاطئة أي حالات التطابق وعدم التطابق). والمثال التالي سيوضح كل شيء، حيث قمت في البداية بكتابة كود بشكل يدوي لتحقيق هذا التابع ثم استخدمت كيراس:
# تحميل المكتبات import numpy import tensorflow as tf #One-Hot تشكيل مصفوفتين واحدة للقيم الحقيقية مرمزة بترميز label = numpy.array([[0,0,0,1,0],[0,0,1,0,0],[0,0,1,0,0],[0,1,0,0,0]]) # الثانية تمثل القيم المتوقعة Pred = numpy.array([[0,0.2,0,1,0],[0,0.3,0,1,0],[0.12,0.2,0.6,0.7,0.1], [0.6,0.9,0,0,0]]) #argmax() استخدام تابع لامدا لتحديد الفهرس الذي يملك أعلى قيمة باستخدام التابع max = lambda x : numpy.argmax(x) # باستخدام التابع الذي قمنا بتعريفه سنقوم بتشكيل قائمتين لكل من القيم المتوقعة والحقيقية، تحوي فهارس القيم (الفهرس الذي يقابل أعلى قيمة) لكي نستخدمها في عملية المقارنة # مثال: [0,0,0,1,0]-->3 labelMax = numpy.array([max(n) for n in label]) print("labelMax: ",labelMax,sep="\n") # [3 2 2 1] PredMax = numpy.array([max(n) for n in Pred]) print("PredMax: ",PredMax,sep="\n") # [3 3 3 1] # عدد التوقعات الصحيحة print("accurately predicted: ",sum(labelMax == PredMax)) # Categorical Accuracy: عدد حالات التطابق على العدد الكلي للتوقعات CAccuracy = sum(PredMax == labelMax)/len(PredMax) print("Categorical Accuracy: ",CAccuracy) # حسابها باستخدام كيراس metric = tf.keras.metrics.CategoricalAccuracy() metric.update_state(label,Pred) metric.result().numpy() """ labelMax: [3 2 2 1] PredMax: [3 3 3 1] accurately predicted: 2 Categorical Accuracy: 0.5 <==>50% 0.5 <==>50% """ هذه الدالة لها الشكل التالي في كيراس:
tf.keras.metrics.CategoricalAccuracy(name="categorical_accuracy", dtype=None) ويمكننا استخدامها في نماذجنا مع الدالة compile كالتالي:
model.compile( ... metrics=[tf.keras.metrics.CategoricalAccuracy()]) # أو من واجهة كيراس مباشرةً import keras model.compile( ... metrics=[keras.metrics.CategoricalAccuracy()]) # أو بالشكل التالي model.compile( ... metrics=["CategoricalAccuracy"]) انظر للمثال التالي، حيث سأستخدمها مع مسألة تصنيف متعدد:
from keras.datasets import reuters (train_data, train_labels), (test_data, test_labels) = reuters.load_data( num_words=10000) import numpy as np def vectorize_sequences(sequences, dimension=10000): results = np.zeros((len(sequences), dimension)) for i, sequence in enumerate(sequences): results[i, sequence] = 1. return results x_train = vectorize_sequences(train_data) x_test = vectorize_sequences(test_data) from keras.utils.np_utils import to_categorical one_hot_train_labels = to_categorical(train_labels) one_hot_test_labels = to_categorical(test_labels) x_val = x_train[:1000] partial_x_train = x_train[1000:] y_val = one_hot_train_labels[:1000] partial_y_train = one_hot_train_labels[1000:] # بناءالنموذج from keras.datasets import reuters (train_data, train_labels), (test_data, test_labels) = reuters.load_data( num_words=10000) # تررميز البيانات import numpy as np def vectorize_sequences(sequences, dimension=10000): results = np.zeros((len(sequences), dimension)) for i, sequence in enumerate(sequences): results[i, sequence] = 1. return results x_train = vectorize_sequences(train_data) x_test = vectorize_sequences(test_data) from keras.utils.np_utils import to_categorical one_hot_train_labels = to_categorical(train_labels) one_hot_test_labels = to_categorical(test_labels) x_val = x_train[:1000] partial_x_train = x_train[1000:] y_val = one_hot_train_labels[:1000] partial_y_train = one_hot_train_labels[1000:] # بناء النموذج from keras import models from keras import layers model = models.Sequential() model.add(layers.Dense(64, activation='relu', input_shape=(10000,))) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(46, activation='softmax')) # التجميع model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['CategoricalAccuracy']) # التدريب history = model.fit(partial_x_train, partial_y_train, epochs=6, batch_size=512, validation_data=(x_val, y_val)) """ Epoch 1/6 16/16 [==============================] - 2s 75ms/step - loss: 3.0325 - categorical_accuracy: 0.4249 - val_loss: 1.6946 - val_categorical_accuracy: 0.6590 Epoch 2/6 16/16 [==============================] - 1s 51ms/step - loss: 1.4645 - categorical_accuracy: 0.6999 - val_loss: 1.3093 - val_categorical_accuracy: 0.7150 Epoch 3/6 16/16 [==============================] - 1s 53ms/step - loss: 1.0611 - categorical_accuracy: 0.7740 - val_loss: 1.1516 - val_categorical_accuracy: 0.7480 Epoch 4/6 16/16 [==============================] - 1s 53ms/step - loss: 0.8315 - categorical_accuracy: 0.8172 - val_loss: 1.0494 - val_categorical_accuracy: 0.7790 Epoch 5/6 16/16 [==============================] - 1s 53ms/step - loss: 0.6774 - categorical_accuracy: 0.8535 - val_loss: 0.9816 - val_categorical_accuracy: 0.7860 Epoch 6/6 16/16 [==============================] - 1s 51ms/step - loss: 0.5694 - categorical_accuracy: 0.8753 - val_loss: 0.9275 - val_categorical_accuracy: 0.8000 """  

الطريقة الأولى هي استخدام ()numpy.nan و  ()numpy.logical_not. فلتكن لدينا المصفوفة التالية:
a = numpy.array([2, 8, numpy.nan, 3, 1, numpy.nan]) ولو طبقنا عليها numpy.isnan سوف يعيد لنا نفس المصفوفة لكن بقيم بوليانية بحيث يضع true مكان القيم التي ليست nan و false مكان القيم nan:
print(numpy.isnan(a)) # [False False True False False True] الآن لو استخدمنا على الناتج السابق التابع logical_not فسوف يعكس النتائج، أي بدل true سيضع false والعكس:
print(numpy.logical_not(numpy.isnan(a))) # [ True True False True True False] الآن يمكننا الاستفادة من الفكرة التالية:
e=(np.array([1, 0, 3,4])) e[[True, True, True,False]] # array([1, 0, 3]) لذا يكون  الحل كالتالي:
import numpy # إنشاؤ المصفوفة a = numpy.array([2, 8, numpy.nan, 3, 1, numpy.nan]) #numpy.logical_not و numpy.isnan(): باستخدام #nan سنقوم بحذف قيم print(numpy.isnan(a)) # [False False True False False True] print(numpy.logical_not(numpy.isnan(a))) # [ True True False True True False] b = a[numpy.logical_not(numpy.isnan(a))] print(b) # [2. 8. 3. 1.] مثال آخر على مصفوفة ثنائية:
import numpy # إنشاؤ المصفوفة a = numpy.array([[6, 2, numpy.nan], [2, 6, 1], [numpy.nan, 1, numpy.nan]]) #numpy.logical_not و numpy.isnan(): باستخدام #nan سنقوم بحذف قيم print(numpy.isnan(a)) """ [[False False True] [False False False] [ True False True]] """ print(numpy.logical_not(numpy.isnan(a))) """ [[ True True False] [ True True True] [False True False]] """ b = a[numpy.logical_not(numpy.isnan(a))] print(b) # [6. 2. 2. 6. 1. 1.] أو يمكنك استخدام المعامل ~ بدلاً من logical كالتالي:
import numpy a = numpy.array([[12, 5, numpy.nan, 7], [2, 61, 1, numpy.nan], [numpy.nan, 1, numpy.nan, 5]]) a = a[~(numpy.isnan(c))] a #array([12., 5., 7., 2., 61., 1., 1., 5.]) أو من خلال التابع isfinite في نمباي (بنفس المبدأ) :
import numpy a = numpy.array([[12, 5, numpy.nan, 7], [2, 61, 1, numpy.nan], [numpy.nan, 1, numpy.nan, 5]]) a[np.isfinite(a)] # array([12., 5., 7., 2., 61., 1., 1., 5.])  

del تستخدم مع القوائم وليس مصفوفات نمباي على ما اعتقد، لذالك يظهر الخطأ. هناك عدة طرق للحذف من نمباي، فيمكنك استخدام التابع setdiff1d من نمباي، حيث نمرر له المصفوفة الأصلية والقيم التي نريد حذفها موضوعة ضمن مصفوفة:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]) # مصفوفة بالقيم التي نريد حذفها b = np.array([1,2,4]) arr = np.setdiff1d(arr,b) arr # array([3, 5, 6, 7, 8, 9]) أو من خلال التابع delete لكن هنا نمرر له ال index المراد حذفها وليس القيم:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]) b = np.delete(arr, [2,3,6]) #index هنا نمرر له ال b #array([1, 2, 5, 6, 8, 9]) # لحذف عنصر واحد من خلال الفهرس array = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] index = 2 array = np.delete(array, index) array # array([ 10, 20, 40, 50, 60, 70, 80, 90, 100]) أيضاً هنا يتم الحذف من خلال تحديد الفهرس عن طريق استخدام itertools.compress وهي الطريقة الأسرع:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]) import itertools index=[2,3,6] arr = np.array(list(itertools.compress(arr, [i not in index for i in range(len(arr))]))) arr # array([1, 2, 5, 6, 8, 9]) حسناً الطرق السابقة كانت من أجل مصفوفات نمباي، لكن هناك طرق أخرى خاصة بالقوائم، فمثلاً يمكنك تحويل المصفوفة إلى قائمة ثم حذف العنصر من القائمة بإحدى الطرق التالية، ثم إعادة تحويلها لمصفوفة. استخدام Remove لحذف عنصر محدد:
array = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] array.remove(40) #[10, 20, 30, 50, 60, 70, 80, 90, 100] أو pop لحذف عنصر من خلال تمرير ال index:
array = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] index = 2 array.pop(index) array # [10, 20, 40, 50, 60, 70, 80, 90, 100] أو من خلال del وأيضاً من خلال ال index:
array = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] index = 2 del array[index] array # [10, 20, 40, 50, 60, 70, 80, 90, 100]