ريم المهدي

هي نوع من أنواع خوارزميات التحسين وهي إمتداد لAdam والتي تستخدم infinity norm بدلاً من L2 norm كما تفعل Adam. والان لنعرف ما هو norm هي عبارة عن دالة تحول المدخل لمخرج معين، وذلك بإدراج طول موجب لvector متجه معين، وبالتالي فهي تخبرنا بطول المتجه، هنالك العديد من أنواع الnormalities التي يمكن أن تطبق،منها L1 norm وهو الذي يعطي طول المتجه في شكل blocks و L2 norm الذي يخرج الناتج في شكل أقصر طريقة للوصول بين نقطتين أو بحساب Euclidian distance وفي هذه الحالة الحساب يعتمد على قيمة p والتي تساوي 2 لكن حينما تزيد قيمة الp تصل لأعلى قيمة ممكنة لها نسميها infinity norm وهي التي تستخدم في حالة AdaMax. في هذه الحالة p ترمز لمتوسط الأوزان في تدريب النموذج، كلما زادت قيمة p كان للنموذج القدرة على الحصول على دقة أعلى. يمكن إستخدام Adamax بإحدى طريقتين: بعد إستيراد المكتبات اللازمة، تم تعريف نموذج و إضافة عدد 2Layers الأولى تحتوي على شكل البيانات المدخلة و عدد الneurons الثانية تحتوي على دالة التنشيط activation function وهي المسؤولة عن إضافة non-linearity للنموذج. بعد ذلك عرفنا دالة الموانة Adamax بإستخدام القيم الإفتراضية. ومن ثم نقوم بتعريف الoptimizer في model.compile. from tensorflow import keras from tensorflow.keras import layers model = keras.Sequential() model.add(layers.Dense(64, kernel_initializer='uniform', input_shape=(10,))) model.add(layers.Activation('softmax')) opt = keras.optimizers.Adamax() model.compile(loss='categorical_crossentropy', optimizer=opt) تذكر أن model.compile تقوم بالأتي: بالتالي نحن نحتاج إلى عملية التجميع قبل أن نقوم بأي عملية تدريب للنموذج. يمكننا أن نقوم بتمرير الoptimizer إلى دالة التجميع مباشرة دون التعريف المسبق كالتالي: model.compile(loss='categorical_crossentropy', optimizer='Adamax')

هل قمت بكتابة أي جزء برمجي؟ يمكنك مشاركته معنا و سنساعدك في حال واجهتك أي مشاكل تقنية.

هي إحدي الدوال التي تستخدم لقياس دقة النموذج و بالتالي حساب معدل الخسارة loss و ذلك عن طريق إيجاد متوسط الفروقات بين القيم الحقيقية و المتوقعة بإستخدام النموذج. كلما قلت القيمة الناتجة من الدالة كلما زادت دقة النموذج، و يكون إستخدامه مفيداَ في حالة قياس دقة النماذج المطبقة على البيانات التي تحتوي على قيم شاذة أو متطرفة. يمكننا إستدعاء دالة mean_absolute_error من sklearn.metrics مباشرة أو القيام ببرمجته مباشرة فهو من أسهل المقاييس: from sklearn.metrics import mean_absolute_error as MAE import pandas as pd y_true = pd.DataFrame({'values':[3,6,5,8,9,4,2]}) y_pred = [4,8,7,3,2,4,2] error = 0 for i in range(len(y_true)): error += abs(y_true.values[i] - y_pred[i]) print('manual MAE = ', error / len(y_true)) print('sklearn MAE = ', MAE(y_true, y_pred)) لاحظ لنتيجة كل من الدالتين والتي تكون متقاربة لحد كبير، ويمكننا إظهار كل الأرقام الكسرية في دالة MAE المحسوبة بالبرنامج بزيادة عدد الأرقام الظاهرة في الطباعة. manual MAE = [2.42857143] sklearn MAE = 2.4285714285714284 لاحظ من البرنامج أن دالة MAE قامت بإستقبال القيم الحقيقية y والقيم المتوقعة y_pred وقامت بالحسابات ضمنياً، ويمكن لنفس الدالة إستقبال multioutput والتي يمكن تعريفها في حال كنا نريد إرجاع MAE لكل feature على حدة، و يمكننا أيضاً تمرير sample_weight والتي تقوم بإسناد معاملات لمعدل الفقد. y_true = [[0., 1.], [0., 0.]] y_pred = [[1., 1.], [1., 0.]] #تطبيق sample weight MAE(y_true, y_pred, sample_weight=[0.7, 0.3]) #تطبيق multioutput MAE(y_true, y_pred, multioutput='raw_values') في حالة تطبيق multioutput بدلاً من تمرير معاملات لكل الخصائص في مجموعة البيانات قمنا بتمرير raw_values وهي ترجع كل قيم MAE لكل خاصية على حدا.

هنالك خطوتين في هذا السؤال الأولى هي إنشاء البيانات العشوائية و الثانية هي عملية إضافة العمود أو الأعمدة الجديدة: import numpy as np N = 3 a = np.array([[1, 2,],[3, 4]]) b = np.random.random((N,a.shape[1])) np.ascontiguousarray(numpy.vstack([a, b]).T) في البرنامج السابق قمنا بإستيراد numpy و من ثم تعريف عدد القيم الجديدة التي نود إضافتها و مناداة الدالة random من مكتبة numpy.random وبعد تمرير الشكل إستخدمنا vstack لإلصاق القيم الجديدة بالمصفوفة a لكن لتسريع العملية إستخدمنا ascontiguousarray والتي تتعامل مع contiguous array في الذاكرة بالتالي فهي أسرع، لاحظ لنتيجة إختبار سرعات الدوال التالية:

يمكنك ذلك عن طريق إستخدام الدالة rank_filter، لاحظ البرنامج التالي و الذي يرجع True في حال كانت القيم هي عبارة عن local minima, local maxima بالمقارنة مع القيم المجاورة: import numpy as np from scipy.ndimage import rank_filter def find_local_maxima(x): x_dilate = rank_filter(x, -1, size=3) return x_dilate == x def find_local_minima(x): x_erode = rank_filter(x, -0, size=3) return x_erode == x myArray = np.array([3, 5, 3, 5, 3]) maxima = find_local_maxima(myArray) minima = find_local_minima(myArray) لاحظ بعد تعريف الدوال find_local_minima, find_local_maxima قمنا بندائها و حفظ الناتج في maxima, minima وهي المصفوفات التي تحتوي على قيم true, false لأماكن ال local minima, local maxima وللقيام بإستخراج القيم نفسها يمكن المرور بfor loop على المصفوفتين و إيجاد القيم التي مواقعها تساوي true. maxima_values = [myArray[i] for i in np.where(maxima)[0]] minima_values = [myArray[i] for i in np.where(minima)[0]]

هي الدالة التي تقوم بحساب نسبة الخطأ أو الفقد Loss للبيانات بإستخدام طريقة بواسون وهو موجود ب tensorflow.keras.losses و يقوم بإستقبال القيم المتوقعة من النموذج و القيم الحقيقية لحساب الخطأ. لاحظ المثال البسيط المطبق على الدالة: import tensorflow as tf y_true = [[0., 1.], [0., 0.]] y_pred = [[1., 1.], [0., 0.]] p = tf.keras.losses.Poisson() p(y_true, y_pred).numpy() بعد أن عرفنا tensorflow قمنا بإنشاء قيم لتمثل البيانات الحقيقية و البيانات المتوقعة من قبل النموذج، و بإستخدام دالة الفقد Poisson قمنا بحساب نسبة الخطأ والتي تعتمد على توزيع البيانات. قام @Ali Haidar Ahmad بتطبيق مثال على عملية التصنيف، سأقوم بتطبيق مثال اخر على عملية الregression: from keras import models, layers from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split X, y = load_boston(return_X_y=True) X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.4) print(X_train.shape, y_train.shape,X_test.shape, y_test.shape) model = models.Sequential() model.add(layers.Dense(13, activation='linear', input_shape=(13,))) model.add(layers.Dense(26, activation='sigmoid')) model.add(layers.Dense(1, activation='tanh')) model.compile(optimizer='rmsprop',loss=tf.keras.losses.Poisson(),metrics=['mse']) model.fit(X_train, y_train, epochs=3, batch_size=200) في المثال السابق قمنا بإستيراد الدوال التي سنتعامل معها، بالإضافة لتحميل dataset وهي خاصة بإسعار المنازل في بوسطن (regression dataset). بعد ذلك قسمنا البيانات و تعريف النموذج و من ثم تجميع البيانات و تدريب النموذج، لاحظ أن دالة حساب الخطأ او الفقد المستخدمة هي Poisson.

الخطأ كما وضح @Ali Haidar Ahmadينتج عند الإنتقال من طبقة لأخرى، بشكل افتراضي يحتوي ناتج طبقة RNN على متجه واحد لكل عينة. هذا المتجه هو خرج RNN المقابل لآخر خطوة زمنية time step ، ويحتوي على معلومات حول تسلسل الإدخال بأكمله و يكون شكله هو (batch_size, units) حيث تتوافق units مع الرقم الممرر للنموذج لعدد الوحدات. بالتالي، لمعالجة المشكلة يجب إضافة return_sequences=True والتي تقوم بإرجاع التسلسل كامل للقيم الناتجة من تنفيذ النموذج في الطبقة المعنية (هنا الطبقة الأولى لأنها ستمرر القيم لSimpleRNN مرة أخرى) و سيكون الشكل الممرر عبارة عن (batch_size, timesteps, units). لاحظ الإختلاف في المثالين الثاليين: بدون retrun_sequence: from keras.models import Model from keras.layers import Input, SimpleRNN from numpy as np # تعريف النموذج inputs1 = Input(shape=(3, 1)) lstm1 = SimpleRNN(1)(inputs1) model = Model(inputs=inputs1, outputs=lstm1) # تعريف البيانات المدخلة data = np.array([0.1, 0.2, 0.3]).reshape((1,3,1)) # توقع البيانات بإستخدام النموذج و طباعة الناتج print(model.predict(data)) بإستخدام return_sequence: from keras.models import Model from keras.layers import Input, SimpleRNN import numpy as np # تعريف النموذج inputs1 = Input(shape=(3, 1)) lstm1 = SimpleRNN(1, return_sequences=True)(inputs1) model = Model(inputs=inputs1, outputs=lstm1) # تعريف البيانات المدخلة data = np.array([0.1, 0.2, 0.3]).reshape((1,3,1)) # توقع البيانات بإستخدام النموذج و طباعة الناتج print(model.predict(data)) لاحظ الفرق في الناتج، في المرة الأولى لدينا مدخل ب3 time steps وهو ناتجه عبارة عن قيمة واحدة من تنفيذ دالة SimpleRNN وهنا قيم الأوزان و القيم المبدئية يتم إختيارها عشوائياً. أما في الحالة الثانية فالغرض كان إخراج نتيجة تطبيق SimpleRNN لكل قيمة مدخلة من ال3 time steps. لذلك كان الناتج 3 قيم منفصلة، لاحظ الناتج الذي تحصلت عليه: # بدون إرجاع القيم لكل سلسلة زمنية [[0.6872494]] # مع إرجاع الناتج لكل سلسلة زمنية منفصلة [[[0.07889937] [0.0790627 ] [0.15682352]]]

دالة Sparse Categorical Cross Entropy موجودة في مكتبة tensorflow.keras.losses وهي التي تقوم بحساب قيمة الفقد loss بين البيانات المتوقعة من قبل نموذج التصنيف و أصناف العينات الحقيقية. وهي تقوم بنفس ما تقوم به Categorical Cross Entropy المشروحة هنا وذلك حسب البرنامج المعرف في TensorFlow لكن الفرق الوحيد هو ان Sparse Categorical Cross Entropy تقوم بإستقبال القيم المدخلة للنموذج في شكل أرقام عكس Categorical Cross Entropy التي تستقبلها بعد عملية التحويل بإستخدام one hot encoding. لاحظ المثال التالي: import tensorflow as tf m = tf.keras.metrics.SparseCategoricalCrossentropy() m.update_state([1, 2], [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]) m.result().numpy() لاحظ ان القيم الحقيقية الداخلة للنموذج عبارة عن [1, 2] وليست معرفة كترميز [0, 1, 0], [0, 0, 1] كما حصل مع Categorical Cross Entropy. أما إن كنا نريد تطبيقSparse Categorical Cross Entropy على نتائج النماذج المختلفة فيمكن ذلك بإستخدام model.compile: model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.SparseCategoricalCrossentropy()]) كما يمكن تعريف الدالة خارج model.compile وندائها لاحقاً كما ذكر @Ali Haidar Ahmad.

دالة Categorical Cross Entropy موجودة في مكتبة tensorflow.keras.losses وهي التي تقوم بحساب قيمة الفقد loss بين البيانات المتوقعة من قبل نموذج التصنيف و أصناف العينات الحقيقية. وال cross entropy هو عملية حساب الإختلاف بين توزيع إحتمالات probability distribution لمجموعتين تحتوى على مجموعة من البيانات. تعرف دالة ال CategoricalCrossentropy كالأتي: tf.keras.metrics.CategoricalCrossentropy( name='categorical_crossentropy', dtype=None, from_logits=False, label_smoothing=0 ) حيث أن: name: عبارة عن إسم الدالة التي سيتم النداء بها لاحقاً. dtype: تشير لنوع النتائج التي ستخرجها الدالة. from_logits: وهي تشير لنوع العملية التي ستتم في البيانات وتعني أن مجموع البيانات الداخلة قد لا يساوي 1 و بالتالي هو ليس بإحتمال. label_smoothing: عبارة عن قيمة رقمية بين 0 و 1 و إذا كانت القيمة أكبر من 0 تعني أن البيانات تمت فيها عملية smoothing. يمكن تطبيق الدالة CategoricalCrossentropy كالتالي: import tensorflow as tf m = tf.keras.metrics.CategoricalCrossentropy() m.update_state([[0, 1, 0], [0, 0, 1]], [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]) m.result().numpy() الدالة تتوقع القيم أن تكون مكررة بعد تطبيق one hot encoding عليها. الدالة update_state هي التي تقوم بإستقبال القيم الحقيقية و المتوقعة ويمكنها ايضا أن تقوم بإستقبال sampe_weight لحساب النتائج (sample_weight هي الدالة التي تعطي الأصناف أوزان مختلفة في حال كانت البيانات تحتوي على صنف واحد أكثر من البقية). و أخيراً result هي التي تطبع النتائج. أما إن كنا نريد تطبيق Categorical Cross Entropy على نتائج النماذج المختلفة فيمكن ذلك بإستخدام model.compile: model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.CategoricalCrossentropy()]) في المثال السابق بعد أن حددنا نوع optimizer و loss function قمنا بتحديد دالة حساب الخطأ وهي ()CategoricalCrossentropy.

إن كنتي تريدين إنشاء ملف نصي في Windows الذهاب إلى المجلد الذي تريدين إنشاء الملف فيه و من ثم الضغط من على الفأرة بإستخدام الزر الأيمن لتظهر لك القائمة كما في الشكل و من ثم إختيار new أو جديد و ستظهر منه قائمة فرعية جديدة يمكنك الضغط على خيار الملف النصي Text Document: والان يمكنك تغيير الإسم الإفتراضي بعد أن يتم تظليله كما في الصورة، أدخل الإسم الجديد و إضغط على Enter من لوحة المفاتيح: أما إن كنت تريد إنشاء الملف النصي بإستخدام لغة بايثون فيمكن عمل التالي: f = open("myfile.txt", "w") إستخدام عبارة open تقوم بفتح الملف المحدد داخل الأقواس myfile.txt و تنشئه في حال كان غير موجود، حرف w بعد إسم الملف يشير إلى نوع العملية التي ستتم فيه و هي عبارة عن الكتابة write.

وفي حال لم تكن تعرف عدد العينات في كل من المصفوفات المراد تحويل شكلها يمكنك القيام بالتالي: x_train = np.reshape(x_train, (-1, 28, 28, 1)) x_test = np.reshape(x_test, (-1, 28, 28, 1)) والان لاحظ أن البرنامج لن ينفذ و ينتج الخطأ التالي: ValueError: Shapes (60, 1) and (60, 10) are incompatible لتفادي ذلك يجب تحويل مصفوفات y_train, y_test إلى التمثيل المقابل لها في الone hot encoding بإستخدام دالة to_categorical لأن عملية التصنيف إلى 10 أصناف تتتطلب ذلك لاحظ keras.layers.Dense(10): y_train = to_categorical(y_train) y_test = to_categorical(y_test) والان البرنامج يصبح كالتالي: import numpy as np import keras from keras.models import Sequential from keras.layers import Dense , Activation, Dropout from keras.optimizers import Adam ,RMSprop from keras.models import Sequential from keras.utils.np_utils import to_categorical from keras.datasets import mnist (x_train, y_train),(x_test, y_test) = mnist.load_data() print(x_train.shape, y_train.shape,x_test.shape, y_test.shape) x_train = np.reshape(x_train, (-1, 28, 28, 1)) x_test = np.reshape(x_test, (-1, 28, 28, 1)) print(x_train.shape, y_train.shape,x_test.shape, y_test.shape) # y تطبيق على قيم one hot encoding y_train = to_categorical(y_train) y_test = to_categorical(y_test) print(x_train.shape, y_train.shape,x_test.shape, y_test.shape) model = keras.models.Sequential([ keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=(28,28,1)), keras.layers.MaxPool2D(2,2), keras.layers.Conv2D(64, (3,3), activation='relu'), keras.layers.MaxPool2D(2,2), keras.layers.Flatten(), keras.layers.Dense(128, activation='relu'), keras.layers.Dense(10, activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(x_train, y_train, epochs=20,validation_data=(x_test, y_test), batch_size=60)

يمكنك ايضاً إستخدام الدالة append لإضافة المسار في حال كنت في نفس المجلد الموجود فيه الملف الذي تريد الوصول إليه: import sys, os, inspect currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) parentdir = os.path.dirname(currentdir) sys.path.insert(0, parentdir) import myfile as f يبدأ البرنامج أولا بإستيراد الدوال اللازمة، و من ثم لإستيراد file يجب أن يكون مقروء في PYTHONPATH وهي عبارة عن متغير البيئة الذي يقوم بتحميل كل المكتبات و الملفات التي سيتم تحميلها في بايثون لإتمام عملية التنفيذ وهي ايضاً الملفات التي تكون متوفرة في sys.path يتم التحميل كما هو موضح في السطر الثاني، لاحظ أن الفرق بين append و insert هو أن append تقوم بالإضافة في نهاية sys.path مباشرة لكن insert تقوم بإدراجه في مؤشر محدد كما في حالتنا 0.

يمكنك البدء و كتابة البرنامج و سنساعدك إن واجهتك أي أخطاء.

لقد تحدثت عن خوارزميات التحسين و أهميتها للنموذج هنا، يمكنك مراجعة المقدمة لتتعرف على أهميتها. والان بعد أن قمت بفهم أهمية خوارزميات التحسين لنتحدث عن Adam optimizer بالتحديد. Adam هو من خوارزميات الإتزان البديلة لstochastic gradient descent وهو يعد من أفضل الخوارزميات و ذلك لسهولة تعامله مع البيانات الضخمة و معدل التعلم المتغير حسب البيانات و بذلك فهو يصل لنتائج النماذج العميقة بصورة أسرع. الشكل الإفتراضي لAdam optimizer: tf.keras.optimizers.Adam( learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07, amsgrad=False,name='Adam') [إضغط و إسحب للتحريك] والذي يحتوى على الparameters hالتالية: learning_rate: هو المعدل الذي تتغير به الأوزان في النموذج. beta_1: معدل التناقص التسارعي لمعدل التعلم (exponential decay) للمرة الأولى. beta_2: معدل التناقص التسارعي لمعدل التعلم (exponential decay) للمرة الثانية. epsilon: معامل حفظ توازن النموذج الرياضي (لمنع القيام بعمليات مثل القسمة على 0). لابد أنك لاحظت وجود معدلين للتناقص التسارعي أو الأسي في الخوارزمية، و السبب يرجع لطريقة حساب الخوارزمية، فهي تحسب التغير في متوسط الأوزان و في متوسط مربعات الأوزان للتحكم في معدل التغير. يمكن إستخدام Adam بإحدى طريقتين: بعد إستيراد المكتبات اللازمة، تم تعريف نموذج و إضافة عدد 2Layers الأولى تحتوي على شكل البيانات المدخلة و عدد الneurons الثانية تحتوي على دالة التنشيط activation function وهي المسؤولة عن إضافة non-linearity للنموذج. بعد ذلك عرفنا دالة الموانة Adam بإستخدام القيم الإفتراضية. ومن ثم نقوم بتعريف الoptimizer في model.compile. from tensorflow import keras from tensorflow.keras import layers model = keras.Sequential() model.add(layers.Dense(64, kernel_initializer='uniform', input_shape=(10,))) model.add(layers.Activation('softmax')) opt = keras.optimizers.Adam() model.compile(loss='categorical_crossentropy', optimizer=opt) تذكر أن model.compile تقوم بالأتي: Compile defines the loss function, the optimizer and the metrics. بالتالي نحن نحتاج إلى عملية التجميع قبل أن نقوم بأي عملية تدريب للنموذج. يمكننا أن نقوم بتمرير الoptimizer إلى دالة التجميع مباشرة دون التعريف المسبق كالتالي: model.compile(loss='categorical_crossentropy', optimizer='Adam') [إضغط و إسحب للتحريك]

لقد تحدثت عن خوارزميات التحسين و أهميتها للنموذج هنا، يمكنك مراجعة المقدمة لتتعرف على أهميتها. والان بعد أن قمت بفهم أهمية خوارزميات التحسين لنتحدث عن Adam optimizer بالتحديد. Adam هو من خوارزميات الإتزان البديلة لstochastic gradient descent وهو يعد من أفضل الخوارزميات و ذلك لسهولة تعامله مع البيانات الضخمة و معدل التعلم المتغير حسب ال يمكن إستخدام Adam بإحدى طريقتين: بعد إستيراد المكتبات اللازمة، تم تعريف نموذج و إضافة عدد 2Layers الأولى تحتوي على شكل البيانات المدخلة و عدد الneurons الثانية تحتوي على دالة التنشيط activation function وهي المسؤولة عن إضافة non-linearity للنموذج. بعد ذلك عرفنا دالة الموانة Adam بإستخدام القيم الإفتراضية. ومن ثم نقوم بتعريف الoptimizer في model.compile. from tensorflow import keras from tensorflow.keras import layers model = keras.Sequential() model.add(layers.Dense(64, kernel_initializer='uniform', input_shape=(10,))) model.add(layers.Activation('softmax')) opt = keras.optimizers.Adam() model.compile(loss='categorical_crossentropy', optimizer=opt) تذكر أن model.compile تقوم بالأتي: بالتالي نحن نحتاج إلى عملية التجميع قبل أن نقوم بأي عملية تدريب للنموذج. يمكننا أن نقوم بتمرير الoptimizer إلى دالة التجميع مباشرة دون التعريف المسبق كالتالي: model.compile(loss='categorical_crossentropy', optimizer='Adam')

يمكن أن يكون المترجم موجود لكن تغيرت الإعدادات الإفتراضية لCode::Blocks يمكنك القيام الرجوع للقيم الإفتراضية للمترجم بإتباع الخطوات التالية: الذهاب إلى الضبط settings في إعلى الشاشة الضغط على المترجم compiler ومن ثم الضغط على reset to defaults هذا سيقوم بإرجاع القيم الإفتراضية لكل المتغيرات في البرنامج. في حال لم ينجح الأمر يمكنك تتبع الخطوات التالية: الذهاب للضبط و الضغط على compiler and debugger ستفتح نافذة جديدة تحتوي على خيار selected compiler منه قم بإختيار GNU GCC Compiler توجد قائمة متعددة المهام اسفله يمكنك إختيار Toolchain executables منها إضغط على مفتاح Auto-detect والذي سيقوم بالبحث عن موقع المترجم بالجهاز. لكن في حال كان المترجم غير موجود اصلاً يمكنك إعادة تثبيته كما إقترح @عبدالمجيد الجراديأو تنزيل المترجم بصورة منفصلة و تثبيته في الجهاز.

لقد تحدثت عن خوارزميات التحسين و أهميتها للنموذج هنا، يمكنك مراجعة المقدمة فقط لتتعرف على أهميتها. والان بعد أن قمت بفهم أهمية خوارزميات التحسين لنتحدث عن Adadelta بالتحديد. Adadelta هي إختصاراً لadaptive delta و هي دالة مطورة من دوال الإتزان و دلتا هنا تشير للأوزان قبل و بعد التعديل. و ما يميز هذه الخوارزمية تحديداً هو تعديل learning rate بإستخدام عدد من gradient updates و بذلك تتابع التعلم و تعديل learning rate مع التغيير الحاصل في الأوزان. وهي من الخوارزميات التي ينصح بأن تترك بالقيم الإفتراضية التي تأتي بها، موضحة كالاتي: tf.keras.optimizers.Adadelta(learning_rate=0.001, rho=0.95, epsilon=1e-07, name="Adadelta") حيث أن: learning_rate: هو عبارة عن معامل التعلم و هو عبارة عن قيمة كسرية أكبر من 0 rho: قيمة كسرية أكبر من 0 أو مصفوفة تمثل معدل التناقص في معامل التعلم لكل عملية تعديل. epsilon: قيمة كسرية أكبر من 0 و قيمته الإفتراضية هي K.epsilon وهي0.0000001 وهو المسؤول عن جعل العمليات الحسابية مستقرة. يمكن إستخدام Adadelta بإحدى طريقتين: بعد إستيراد المكتبات اللازمة، تم تعريف نموذج و إضافة عدد 2Layers الأولى تحتوي على شكل البيانات المدخلة و عدد الneurons الثانية تحتوي على دالة التنشيط activation function وهي المسؤولة عن إضافة non-linearity للنموذج. بعد ذلك عرفنا دالة الموزانة Adadelta و في هذه الحالة ستسخدم الدالة القيم الإفتراضية. ومن ثم نقوم بتعريف الoptimizer في model.compile . from tensorflow import keras from tensorflow.keras import layers model = keras.Sequential() model.add(layers.Dense(64, kernel_initializer='uniform', input_shape=(10,))) model.add(layers.Activation('softmax')) opt = keras.optimizers.Adadelta() model.compile(loss='categorical_crossentropy', optimizer=opt) تذكر أن model.compile تقوم بالأتي: بالتالي نحن نحتاج إلى عملية التجميع قبل أن نقوم بأي عملية تدريب للنموذج. يمكننا أن نقوم بتمرير الoptimizer إلى دالة التجميع مباشرة دون التعريف المسبق كالتالي: model.compile(loss='categorical_crossentropy', optimizer='Adadelta')

كما ذكر @Ali Haidar Ahmad فإن الناتج من الشبكة يجب أن يحصل لها تسطيح flatten ذلك لأن dense layer لا تقوم بهذه العملية بل تأخذه بنفس الشكل و توصله بالعقد في الشبكة العصبية، و مهمتها الأساسية هي تحويل multidimensional tensor لarray 1d وهي القيمة التي تستقبلها dense layer في neural network، وهي لا تؤثر على حجم batch في عملية التدريب. يمكن مراجعة المزيد من التفاصيل بالتعرف على classes في keras من هنا. والان إذا قمنا بطباعة شكل النموذج بإستخدام model.summary قبل إضافة الflatten و بعدها سنحصل على الأشكال التالية بالتوالي: Model: "sequential_21" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_36 (Conv2D) (None, 148, 148, 6) 168 _________________________________________________________________ average_pooling2d_34 (Averag (None, 74, 74, 6) 0 _________________________________________________________________ conv2d_37 (Conv2D) (None, 72, 72, 16) 880 _________________________________________________________________ average_pooling2d_35 (Averag (None, 36, 36, 16) 0 _________________________________________________________________ dense_56 (Dense) (None, 36, 36, 120) 2040 _________________________________________________________________ dense_57 (Dense) (None, 36, 36, 84) 10164 _________________________________________________________________ dense_58 (Dense) (None, 36, 36, 6) 510 ================================================================= Total params: 13,762 Trainable params: 13,762 Non-trainable params: 0 و بعد الإضافة: Model: "sequential_22" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_38 (Conv2D) (None, 148, 148, 6) 168 _________________________________________________________________ average_pooling2d_36 (Averag (None, 74, 74, 6) 0 _________________________________________________________________ conv2d_39 (Conv2D) (None, 72, 72, 16) 880 _________________________________________________________________ average_pooling2d_37 (Averag (None, 36, 36, 16) 0 _________________________________________________________________ flatten_9 (Flatten) (None, 20736) 0 _________________________________________________________________ dense_59 (Dense) (None, 120) 2488440 _________________________________________________________________ dense_60 (Dense) (None, 84) 10164 _________________________________________________________________ dense_61 (Dense) (None, 6) 510 ================================================================= Total params: 2,500,162 Trainable params: 2,500,162 Non-trainable params: 0 لاحظ تغير عدد الparameters بعد إضافة flatten من (None, 36, 36, 16) إلى (None, 20736).

السبب هو تحويل النموذج من keras.applications module إلى keras.applications.vgg16، يمكنك أيضاً إستدعاء النموذج مباشرة دون الحاجة لتعريفه بداية البرنامج كالتالي: VGG16_MODEL=tf.keras.applications.VGG16(input_shape=IMG_SHAPE, include_top=False) بذلك يمكنك تمرير شكل الصور للتدريب بإلاضافة لتحديد ما إذا كنت تريد ضبط خاص لأخر طبقة layer في النموذج حسب عدد الأصناف في برنامجك. وذلك بإستخدام include_top، إن كانت خاظئة فكل النموذج يتم إستدعائه ما عدا طبقة التصنيف الأخيرة.

ما هو سبب إختيار المصفوفة [4, 5, 6 ,7, 8] ضمن المصفوفات الفرعية؟ العناصر 4و5و7و8 مشتركة بين المصفوفتين الأخريتين،، و لتجد المصفوفات الفرعية المكونة للمصفوفة الرئيسية بإستخدام reshape تحتاج أن يكون عدد الأعمدة * عدد الصفوف = طول المصفوفة و بهذا ستولد المصفوفات المكونة للمصفوفة الرئيسية بدون تكرار في القيم، أما إن كان عدد الأعمدة * عدد الصفوف لا يساوي طول المصفوفة فالدالة ستولد خطأ. ما يمكنني إقتراحه في هذه الحالة هو إستخدام دالة permutation بتحديد القوائم ذات الطول 5 (عدد الأعمدة). import itertools import numpy as np x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) arr = np.array(list(itertools.permutations(set(x),5))) final = [] semifinal = [] for i in arr: semifinal.append(np.array(sorted(i))) final = np.unique(np.array(semifinal),axis=0) بعد إيجاد كل التباديل الممكنة، نقوم بترتيب المصفوفات الداخلية ليسهل عملية إختيار المصفوفات غير المكررة بإستخدام الدالة unique بذلك نكون قد حصلنا على جميع المصفوفات ذات الطول 5 و التي يمكن إيجادها من المصفوفة x.

حين تدريب نموذج Neural Network نقوم بالخطوات التالية: إنشاء أوزان عشوائية للقيام بالعمليات الجبرية اللازمة لتدريب النموذج، في كل دورة تدريب (epoch) يتم مقارنة القيم الناتجة من النموذج مع الحقيقية بإستخدام Loss function، يتم حساب الخطأ (الفرق بين القيم المتوقعة و الحقيقية) لتعديل الأوزان، يتم تعديل الأوزان في النموذج و القيام بإعادة الخطوات (2و3و4) إلى إنتهاء عدد الدورات أو الوصول لقيمة توقف محددة. عملية تعديل الأوزان للوصول للدقة المطلوبة تتم بإستخدام optimizers للوصول للدقة المطلوبة، لأنها في الإصل عملية موازنة بين إنقاص دالة الخسارة loss function و الوصول للأوزان المناسبة. Keras يوفر العديد من optimizers الجاهزة التي يمكن التعامل معاها مباشرة، والتي يمكن التعامل معها بإحدي الطريقتين: بعد إستيراد المكتبات اللازمة، تم تعريف نموذج و إضافة عدد 2Layers الأولى تحتوي على شكل البيانات المدخلة و عدد الneurons الثانية تحتوي على دالة التنشيط activation function وهي المسؤولة عن إضافة non-linearity للنموذج. بعد ذلك عرفنا دالة الموانة RMSprop و تم تمرير 0.01 learning rate. ومن ثم نقوم بتعريف الoptimizer في model.compile . from tensorflow import keras from tensorflow.keras import layers model = keras.Sequential() model.add(layers.Dense(64, kernel_initializer='uniform', input_shape=(10,))) model.add(layers.Activation('softmax')) opt = keras.optimizers.RMSprop(learning_rate=0.01) model.compile(loss='categorical_crossentropy', optimizer=opt) تذكر أن model.compile تقوم بالأتي: بالتالي نحن نحتاج إلى عملية التجميع قبل أن نقوم بأي عملية تدريب للنموذج. يمكننا أن نقوم بتمرير الoptimizer إلى دالة التجميع مباشرة دون التعريف المسبق كالتالي: model.compile(loss='categorical_crossentropy', optimizer='RMSprop') والان لنتعرف RMSprop optimizer وهو إختصار ل Root Mean Squared Propagation و يقوم بالتقليل / الإنقاص من متوسط مربعات الأخطاء (البعد عن القيمة الحقيقية gradient)، و الذي يتم بضرب الأوزان بقيم محددة كما تم شرحه من قبل @Ali Haidar Ahmad لكن الفرق الذي يجعل RMSprop دالة موازنة جيدة هو learning rate معامل التعلم و هو القيمة التي تحافظ على النموذج في حالة توازن و إذا كانت قيمته عالية فإن النموذج سيأخذ زمن قفزات طويلة قد لا تضمن الوصول ل local minima أما إن كان قيمته صغيرة فإن النموذج يأخذ زمن طويل جداً للوصول. لاحظ في الشكل السابق ما نود الوصول إليه هو النقطة الحمراء (الدقة المثالية التي نسبة الخطأ فيها قليلة)، وعند الإبتداء من A لنتمكن من التحرك في صورة إفقية نستخدم الأوزان، لكن لنعرف الإتجاهات و نحدد مقدار القفزات نحتاج لدالة الموازنة التي تستخدم ما قمنا بتعريفه سابقاً learning rate.

يمكنك أيضاً إستخدام الدالة reshape للقيام بعملية تحويل شكل inputx: import numpy as np from keras.models import Sequential from keras import layers inputx= np.random.randint(0,40, 4) inputx = inputx.reshape(-1, 4) model = Sequential() model.add(layers.Embedding(input_dim=40, output_dim=32, input_length=4)) model.add(layers.Flatten()) model.add(layers.Dense(units=5, activation='sigmoid')) model.summary() print(model(inputx)) الدالة reshape تقوم بتحويل البيانات من 4 إلى (4,1) يمكنك أيضاً مراجعة شكل النموذج لمعرفة شكل البيانات المدخلة بإستخدام ()model.summary.

البرنامح الأول يقوم بإختبار القيم من 0 إلى 100 و التحقق ما إذا كانت زوجية أم فردية بإستخدام العبارة الشرطية if و علامة إيجاد باقي القسمة %: for i in range(1, 101): #إنشاء قائمة للأعداد تبدأ من 1 و تنتهي عند 100 # لاحظ أن قيمة التوقف 101 لأن الدالة تتوقف قبل العدد المحدد بواحد if i%2==0: # إلإختبار الشرطي لباقي قسمة العدد إن كان 0 فهو زوجي print(i) # طباعة العدد دالة الإختبار تبدأ من 1 وتختبر باقي قسمته على 2 فهو واحد بذلك ليس عدد زوجي ولن تتم طباعته، و عند الإنتقال للعدد الثاني 2 باقي قسمته تساوي 0 إذن فهمو زوجي تتم طباعته وهكذا حتى باقي الأعداد إلى المئة. البرنامج الثاني لا يقوم بتطبيق أي شرط تحقق، بل يقوم بطباعة الأرقام إبتداء من صفر بزيادة 2 للرقم السابق: z = 0 #إنشاء قيمة إبتدائية while z < 100: #إنشاء الحلقة لكل الأعداد التي تكون أقل من 100 z += 2 # إضافة العدد 2 لقيمة المتغير السابقة print(z) #طباعة قيمة المتغير لاحظ أن هذا البرنامج يبدأ بإنشاء متغير z قيمته تساوى 0 وفي حالة كانت أقل من 100 يقوم بالدخول لتنفيذ ما بداخل الحلقة وهي عملية إضافة 2 بالتالي تصبح قيمة z تساوي 2 و تتم طباعتها، الحلقة تستمر لأن z الجديدة أقل ايضاً من 2 بالتالي تتم إضافة 2 مرة أخرى لz و تتم طباعتها و هكذا إلى الوصول لطباعة العدد 100. الأن يمكننا مقارنة نتائج البرنامجين بإستخدام القوائم و لنرى إن كان البرنامجان يعطيان نفس النتائج: a = [] for i in range(1, 101): if i%2==0: a.append(i) b = [] z = 0 while z < 100: z += 2 b.append(z) a == b القائمة a تحتوى على كل العناصر المطبوعة في البرنامج الأول و b تحتوى على العناصر المطبوعة في البرنامج الثاني، الإختبار البولياني a==b يعطي True بالتالي فناتج البرنامجين واحد. تعليق أخير يفضل إستخدام البرنامج الأول لأنه يضمن تحقق شرط الزوجية، عكس الثاني الذي يعتمد على القيمة الإبتدائية.

الطريقة الأخرى لحل هذه المشكلة هي إستخدام flatten وهي عبارة الدالة المسؤولة عن تحويل 2D array للصور لمصفوفة ذات بعد واحد بدلا من بعدين بذلك تصبح 28*28 => 1*784. و تضاف flatten لأول طبقة في النموذج (كما يمكن تحديد الشكل المدخل، لكنه اتوماتيكياً يأخذ شكل العينة 2D). والان بعد إستدعاء flatten وإضافتها في أول طبقة في النموذج يصبح البرنامح كالتالي: from keras.models import Sequential from keras import layers import tensorflow as tf from keras.layers import Flatten from tensorflow.keras.datasets import mnist (X_train,y_train),(X_test,y_test)=mnist.load_data() print(X_train.shape,y_train.shape) model = models.Sequential() model.add(Flatten()) model.add(layers.Dense(512, activation='relu')) model.add(layers.Dense(1, activation='softmax')) model.compile(optimizer='Adam',loss='categorical_crossentropy',metrics=['accuracy']) model.fit(X_train,y_train)

في أي حالة تريد أن تقوم بالتعديل على قيمة نصية يمكنك إستخدام StringBuffer and StringBuilder لانهما يسمحان بذلك (Mutable)، مع العلم أن StringBuilder أسرع من StringBuffer. على عكس String والتي لا تسمح بذلك، راجع المثال أدناه: public class example { public static void StrConcat(String str1){ str1 = str1 + "World!"; } public static void StrBufConcat(StringBuffer str2){ str2.append("World!"); } public static void StrBuildConcat(StringBuilder str3){ str3.append("World!"); } public static void main(String[] args){ String str1 = "Hello "; StrConcat(str1); System.out.println("The final String is - " + str1); StringBuffer str2 = new StringBuffer("Hello "); StrBufConcat(str2); System.out.println("The final String is - " + str2); StringBuilder str3 = new StringBuilder("Hello "); StrBuildConcat(str3); System.out.println("The final String is - " + str3); } } من المخرج نلاحظ أنه لم تتم إضافة أي تعديل على المتغير str1 لأنه معرف String Object، عكس القيم المعرفة str2, str3 المعرفة ك StringBuffer, StringBuilder على التوالي: The final String is - Hello The final String is - Hello World! The final String is - Hello World!