Ali Haidar Ahmad

يقوم بجعل قيم البيانات تنتمي إلى المجال من 0 إلى 1، ومبدأ عمله مختلف عن باقي طرق التطبيع "أو التقييس Scaling" في Sklearn حيث يقوم بتناول كل صف على حدى في المصفوفات ثنائية الأبعاد وينفذ عليها عملية التطبيع. ويكون التقييس بإحدى الطرق التالية:
إما باستخدام l1 حيث يجمع مجموع القيم في الصف i وليكن sum ثم يقسم كل قيمة من هذا الصف على sum أي على المجموع. أو l2 بنفس المبدأ لكن هنا يكون جذر مجموع مربعات كل صف هو القيمة العظمى. أو max وهنا القيمة العظمى في كل صف هي القيمة العظمى. ويتم استخدامه في بايثون من مكتبة Sklearn كالتالي:
from sklearn.preprocessing import Normalizer inpt_data = [[1,2,3], [4,5,6], [7,8,9]] transformer =Normalizer(norm='l1') #transformer =Normalizer(inpt_data,norm='l2') #transformer =Normalizer(inpt_data,norm='max') #fit إجراء العمليات اللازمة للتحويل باستخدام التابع transformer.fit(inpt_data) # إجراء التحويل transformer.transform(inpt_data) # الخرج """ array([[0.16666667, 0.33333333, 0.5 ], [0.26666667, 0.33333333, 0.4 ], [0.29166667, 0.33333333, 0.375 ]]) """ وفي Sklearn له الشكل التالي:
sklearn.preprocessing.normalize(X, norm='l2', axis=1, copy=True) # Copy: لتحديد فيما إذا كنت تريد أن يتم تطبيق التغييرات على المصفوفة الأصلية أي إنشاء نسخة أم لا # axis: إذا كان 1 سوف يتم تطبيقه على كل صف أي كل عينة أما 0 فسيتم تطبيقه على كل عمود أي على كل فيتشرز  

بالنسبة للحجم نعم هناك قيود على gmail حيث لا يمكن أن تكون المرفقات أكبر من 25 ميجابايت. يمكنك القيام بماتطلبه من خلال الكود التالي باستخدام مكتبة django:
#لمرفقات البريد الإلكتروني from django.core.mail import EmailMessage def attachment_email(request): email = EmailMessage( 'Hello', #subject: موضوع البريد الإلكتروني 'Body goes here', #body: النص الأساسي 'MyEmail@MyEmail.com', #from: عنوان المرسل ['SendTo@SendTo.com'], #to: قائمة أو مجموعة من عناوين المستلمين ['bcc@example.com'], #bcc: قائمة أو مجموعة من العناوين المستخدمة في عنوان "Bcc" عند إرسال البريد الإلكتروني reply_to=['other@example.com'], headers={'Message-ID': 'foo'}, ) email.attach_file('/my/path/file') email.send() تتم تهيئة الصف EmailMessage بالمعلمات التالية subject و body و from_email و to و bcc و connection و attachments و headers و cc و reply_to . جميع المعلمات اختيارية ويمكن ضبطها في أي وقت قبل استدعاء التابع send().
headers: قاموس من الرؤوس الإضافية لوضعها على الرسالة. المفاتيح هي اسم الرأس ، والقيم هي قيم الرأس. الأمر متروك للمتصل للتأكد من أن أسماء الرأس والقيم بالتنسيق الصحيح لرسالة بريد إلكتروني. السمة المقابلة هي extra_headers. أما reply_to: قائمة أو مجموعة من عناوين المستلمين المستخدمة في عنوان "اreply-to" عند إرسال البريد الإلكتروني.
أيضاُ يمكنك أن تمرر له الوسيط attachments وهو قائمة المرفقات المراد وضعها مع الرسالة. هذا الكلاس لديه التابع attach_file() الذي ينشئ مرفقًا جديدًا باستخدام ملف من نظام الملفات الخاص بك. استدعها بمسار الملف المراد إرفاقه ، واختيارياً ، نوع MIME المراد استخدامه للمرفق. إذا تم حذف نوع MIME ، فسيتم تخمينه من اسم الملف. وأيضاً التابع send لإرسال الرسالة. وتدعم هذه المكتبة العديد من العمليات الأخرى أيضاً لذا يمكنك الذهاب إلى توثيق المكتبة والإطلاع عليها، سيكون ذلك مفيداً لك.
يمكنك أيضاً القيام بذلك كالتالي:
import smtplib from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart from email.mime.application import MIMEApplication from os.path import basename def send_mail(send_from: str, subject: str, text: str, send_to: list, files= None): send_to= default_address if not send_to else send_to msg = MIMEMultipart() msg['From'] = send_from msg['To'] = ', '.join(send_to) msg['Subject'] = subject msg.attach(MIMEText(text)) for f in files or []: with open(f, "rb") as fil: ext = f.split('.')[-1:] attachedfile = MIMEApplication(fil.read(), _subtype = ext) attachedfile.add_header( 'content-disposition', 'attachment', filename=basename(f) ) msg.attach(attachedfile) smtp = smtplib.SMTP(host="smtp.gmail.com", port= 587) smtp.starttls() smtp.login(username,password) smtp.sendmail(send_from, send_to, msg.as_string()) smtp.close() ولاستخدامه:
username = 'my-address@gmail.com' # اسم المستخدم password = 'top-secret' # كلمة المرور default_address = ['my-address2@gmail.com'] # العنوان الافتراضي # إرسال الإيميل send_mail(send_from= username, subject="test", text="text", send_to= None, # المرسل إليه files=Path # مسار ملفاتك ) للاستخدام مع أي مزود بريد إلكتروني آخر ، ما عليك سوى تغيير تكوينات SMTP.

هو مصنف يقوم بالتنبؤات باستخدام قواعد بسيطة. هذا المصنف يتم استخدامه كخط أساس Baseline للمقارنة مع المصنفات الأساسية الأخرى.
sklearn.dummy.DummyClassifier(strategy='prior', random_state=None) # الوسطاء strategy:{“stratified”, “most_frequent”, “prior”, “uniform”, “constant”}, default=”prior” #stratified: يولد تنبؤات على أساس توزيع فئة التدريب #most_frequent: يتنبأ دائمًا بالفئة الأكثر شيوعاً في مجموعة التدريب. #prior: يتنبأ دائمًا بالفئة التي تعظم الفئة السابقة #uniform: يولد تنبؤات بشكل موحد وعشوائي. #constant: يتنبأ دائمًا بتسمية ثابتة يوفرها المستخدم random_state:int, RandomState instance or None, default=None # نظام العشوائية # الواصفات classes_:ndarray of shape (n_classes,) or list of such arrays # الفئات في مجموعة البيانات n_classes_:int or list of int عدد الفئات class_prior_:ndarray of shape (n_classes,) or list of such arrays # احتمالية كل فئة لكل ناتج n_outputs_int # عدد المخرجات # التوابع الأساسية score(X, y): لحساب الدقة predict(X) : للتوقع fit(X,y): للتدريب مثال:
from sklearn.pipeline import make_pipeline from sklearn.model_selection import train_test_split from sklearn.dummy import DummyClassifier from sklearn.datasets import load_breast_cancer # تحميل البيانات Data = load_breast_cancer() X = Data.data y = Data.target pipe = make_pipeline(DummyClassifier()) pipe.fit(X,y) from sklearn.metrics import confusion_matrix,accuracy_score, classification_report # make prediction and print accuracy pipe.score(X, y)  

هذه الطبقة هي  تمثيل للشبكة العصبية المتكررة. وسأعطي لمحة عنها قبل أن أوضح لك كيفية استخدامها في كيراس وتنسرفلو. الشبكة العصبية المتكررة (RNN) هي نوع من الشبكات العصبية حيث يكون الخراج من الخطوة السابقة دخل إلى الخطوة الحالية. في الشبكات العصبية التقليدية، تكون جميع المدخلات والمخرجات مستقلة عن بعضها البعض، ولكن في حالات مثل عندما يكون مطلوباً التنبؤ بالكلمة التالية من الجملة، تكون الكلمات السابقة مطلوبة وبالتالي هناك حاجة لتذكر الكلمات السابقة. وهنا تكمن أهمية شبكات RNN، والتي حلت هذه المشكلة عن طريق استخدام مانسميه "Hidden state"، فهي الميزة الرئيسية والأكثر أهمية لـ RNN، والتي تتذكر بعض معلومات التسلسل. أي أنها تعالج التسلسلات "sequences" كالنصوص و السلاسل الزمنية (رغم أنها ليست ناجحة جداً مع السلاسل كما أشار فرانسوا كوليت).
إن مايميزها هو استخدام "ذاكرة" تتذكر جميع المعلومات حول ما تم حسابه في المراحل السابقة. وتستخدم نفس الأوزان لكل إدخال لأنه يؤدي نفس المهمة على جميع المدخلات أو الطبقات المخفية لإنتاج المخرجات. وهذا يقلل من تعقيد المعلمات، على عكس الشبكات العصبية الأخرى. وأيضاً إحدى المشكلات المتعلقة بالشبكات العصبية التقليدية (وكذلك شبكات CNN) هي أنها تعمل فقط بأحجام محددة مسبقاً، فهي تأخذ مدخلات ذات حجم ثابت وتنتج مخرجات ذات حجم ثابت. أما RNNs تتيح لنا تسلسلات متغيرة الطول كمدخلات ومخرجات. ولهذا فهي الخيار رقم 1 للتعامل مع النصوص ومعالجة اللغة الطبيعية NLP. إن الشيئ الذي يعطي هذه الشبكات الخاصية التكرارية هو أنها تستخدم نفس الأوزان لكل خطوة. وبالضبط فإنها تستخدم (بشكل قياسي) 3 مجموعات فقط من الأوزان لإجراء حساباتها:
Wxh: بين الهيدين ستيت والدخل Whh: بين الهيدين ستيت السابقة والحالية Why: بين الهيدين ستيت والخرج وأيضاً bh: هي الانحراف ويضاف عندما نحسب الهيدين ستيت by: يضاف عندما نحسب المخرجات طبعاً هذه التفاصيل لست مضطراً للخوض بها وحسابها فكيراس وتنسرفلو هي من تقوم بكل شيئ، عن طريق الكلاس SimpleRNN:
tf.keras.layers.SimpleRNN( units, activation="tanh", use_bias=True, dropout=0.0, return_sequences=False, ) حيث أن units هي عدد الخلايا أو الوحدات في الشبكة، أما الوسيط الثاني هو تابع التنشيط المستخدم، أما الثالث فيحدد فيما إذا كنت تريد إضافة الانحراف b الذي أشرنا له في الأعلى (دوماً true)، الوسيط الرابع هو وسيط ال dropout لتحديد نسبة الخلايا التي سيتم إسقاطها في الشبكة (بين 0 و 1) الوسيط الأخير لتحديد شكل الإخراج ففي حال قمت بضبطه على True سوف يكون الخرج 3D حيث يقوم بإعادة كامل التسلسل أما في الحالة الافتراضية أي False يقوم بإعادة الخرج الأخير من تسلسل الخرج. طبعاً لكي لاتقع في الأخطاء يجب أن نضع True إذا كانت الطبقة التالية هي طبقة تكرارية و False إذا كانت طبقة Dense فالطبقات التكرارية دخلها يجب أن يكون 3D بينما طبقات Dense دخلها يكون 2D. والدخل لهذه الطبقة يكون: [batch, timesteps, feature] والخرج: يكون إما 2D أو 3D كما أشرنا.
المثال التالي لاستخدام هذه الطبقة مع مجموعة بيانات imdb لتحليل المشاعر:
from keras.datasets import imdb from keras.preprocessing import sequence max_features = 10000 maxlen = 512 # تحميل البيانات 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 model = Sequential() model.add(Embedding(max_features, 64)) model.add(SimpleRNN(64)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc']) history = model.fit(input_train, y_train, epochs=10, batch_size=64, validation_split=0.2)  

أنت تخلط بين حزم keras و tf.keras.وبالتالي لن يعمل هذا ، لأن هذه الحزم غير متوافقة مع بعضها البعض. يجب استخدام tf.keras فقط في هذه الحالة.
دوماُ عندما تصادفك هذه المشكلة في أي كود، استبدل:
Import keras.<something>.<something> ب:
Import tensorflow.keras.<something>.<something> حيث تشير "something" إلى الوحدة التي تريد استيرادها.
وفي حالتك قم باستبدال:
from keras.layers.embeddings import Embedding ب:
from tensorflow.keras.layers import Embedding  

تظهر هذه المشكلة لأن TensorFlow أو Keras لا يمكنها العمل مع h5py v3 والإصدارات الأحدث. لذا قم بتثبيت نسخة أقدم منها كالتالي:
pip install 'h5py==2.10.0' --force-reinstall ثم أعد تشغيل الKernal (أي قم بإغلاق المحرر وأعد تشغيله أو قم بإعادة تشغيل الحاسب)
غالباً سوف يتم جعل تنسرفلو وكيراس يعملان مع النسخ الأحدث منها قريباً.

يمكنك معرفة ذلك من خلال التعليمة التالية:
model.count_params() مثال:
model = Sequential() model.add(Embedding(1000, 50, input_length=30, trainable=True)) model.add(GRU(150, recurrent_dropout=0.1, dropout=0.1)) model.add(Dense(10, activation='softmax')) model.count_params() #142410 ويمكنك أيضاً استخدام:
model.summary() حيث تعطيك الطريقة الثانية ملخص كامل عن الطبقات الموجودة في نموذجك وعدد المعاملات في كل منها وأبعاد كل طبقة والمعاملات القابلة للتدريب والغير قابلة للتدريب.
# مثال model = Sequential() model.add(Embedding(1000, 50, input_length=30, trainable=True)) model.add(GRU(150, recurrent_dropout=0.1, dropout=0.1)) model.add(Dense(10, activation='softmax')) model.summary() Model: "sequential_2" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= embedding_1 (Embedding) (None, 30, 50) 50000 _________________________________________________________________ gru_1 (GRU) (None, 150) 90900 _________________________________________________________________ dense (Dense) (None, 10) 1510 ================================================================= Total params: 142,410 Trainable params: 142,410 Non-trainable params: 0 _________________________________________________________________  

هذا الخطأ شائع ومثير للحيرة عند المبتدئين، المشكلة في ال  input_shape حيث يجب أن يحتوي 3 أبعاد فقط والبعد الرابع يقوم بإضافته كيراس تلقائياً ويمثل بعد الدفعة batch_size، لكن أنت أضفت البعد الرابع الذي يمثل ال batch وبالتالي أضاف كيراس بعداً آخر فأصبح لدينا 5 أبعاد، لذلك لايجب أن نضيف البعد الرابع والذي يمثل ال batch  أي الحل يكون فقط بتغيير الinput_shape كالتالي:
input_shape=(32,32,1)

اذهب إلى التيرمينال ونفذ الأوامر التالية:
conda uninstall PIL conda uninstall Pillow conda install Pillow ثم:
conda install keras conda install tensorflow وأخيراً قم بإغلاق كل شيء ثم أعد تشغيل الجوبيتر.

الطبقة الكثيفة أو "Dense" هي مجرد طبقة مكونة من وحدات منتظمة نسميها خلايا عصبية في الشبكة العصبية. تتلقى كل خلية عصبية مدخلات من جميع الخلايا العصبية في الطبقة السابقة، وبالتالي نقول عنها "متصلة بكثافة" أو "Densely Connected". تحتوي هذه الطبقة على مصفوفة وزن W ومتجه يمثل الانحراف b بالإضافة لخرج الطبقة السابقة أي خرج تنشيط الطبقة السابقة a. هذه الطبقة تؤدي العملية التالية (حسب وثائق كيراس):
output = activation(dot(input, kernel) + bias) حيث أن ال activation هو تابع التنشيط المستخدم. و ال kernel هي مصفوفة الأوزان الخاصة بهذه الطبقة وال bias هو الانحراف "weights matrix".
لها الشكل التالي:
keras.layers.Dense( units, activation=None, use_bias=True, kernel_initializer="glorot_uniform", bias_initializer="zeros", ) حيث أن units هي عدد الخلايا في الطبقة، و activation هو تابع التنشيط، و use bias لتحديد فيما إذا كنت تريد تفعيل الانحراف أم تجاهله، kernel_initializer مُهيئ لمصفوفة أوزان النواة. bias_initializer أيضاً نفس الأمر لكن لشعاع الانحراف. وعادةً نتركهم على الحالة الافتراضية أي انسى أمرهم، فلا أحد يغيرهم. أما دخل هذه الطبقة هو : (batch_size, ..., input_dim) أي N-D tensor لكن غالباً يكون الإدخال 2D من الشكل (batch_size, input_dim). أما الإخراج (batch_size, ..., units) وفي حالة 2D يكون الخرج (batch_size, units). مثال:
#Dense ثم أضفنا طبقات Sequential قمنا بإنشاء نموذج من النوع model = tf.keras.models.Sequential() # 16 نحدد دخل النموذج ب (None, 16) model.add(tf.keras.Input(shape=(16,))) #relu تعريف طبقة كثيفة ب32 خلية وتابع تنشيط model.add(tf.keras.layers.Dense(32, activation='tanh')) # الخرج سيكون(None, 32). # طبعاً بعد أول طبقة لاداعي لتحديد أبعاد المدخلات إذ يتم استنتاجهم تلقائياً # طبقة أخر model.add(tf.keras.layers.Dense(32)) # أبعاد الإخراج model.output_shape (None, 32)  

تيح لنا طبقة التضمين تحويل كل كلمة إلى متجه بطول ثابت وبحجم محدد. المتجه الناتج هو متجه كثيف "Dense" له قيم حقيقية بدلاً من 0 و 1 فقط كما في الترميز One-Hot. يساعدنا الطول الثابت لمتجهات الكلمات على تمثيل الكلمات بطريقة أفضل وأكثر فعالية مع أبعاد مخفضة. وهذه المتجهات تكون ممثلة في فضاء Vector space مهيكل ويعكس المعاني الدلالية لكل كلمة وهذا مايجعل هذا التمثيل فعال للغاية.
إن أفضل فهم لطبقة التضمين هو اعتبارها كقاموس يقوم بربط أعداد صحيحة (كل كلمة ترمز في البداية كعدد صحيح) بمتجه كثيف. أي أنها تأخذ كدخل أعداد صحيحة ثم تبحث في هذا القاموس على المتجه الذي يقابله في القاموس الداخلي، ويعيد هذا القاموس.
Word index --> Embedding layer --> Corresponding word vector في كيراس نستخدمها كأول طبقة من طبقات النماذج التي تتعامل مع مهام NLP. هذه الطبقة تأخذ وسيطين على الأقل الأول هو عدد ال tokens (المفردات) الموجودة في بياناتك أي (1 + maximum word index) والثاني هو dimensionality of the embeddings أي أبعاد التضمين. وفي حالة كانت الطبقة التالية هي طبقة flatten ثم Dense فيجب عليك استخدام وسيط ثالث هو input_length أي طول مدخلاتك أو بمعنى أوضح، طول السلاسل النصية التي تعالجها. وفي كيراس لها الشكل التالي:
keras.layers.Embedding( input_dim, output_dim, input_length=None, ) هذه الطبقة تأخذ كمدخلات مصفوفة 2D من الشكل:(batch_size, input_length) وتعيد مصفوفة من الشكل: (batch_size, input_length, output_dim)
مثال:
>>> model = tf.keras.Sequential() # طول السلاسل هو 120 وأبعاد التضمين 128 وعدد الكلمات 10000 >>> model.add(tf.keras.layers.Embedding(10000, 128, input_length=120)) >>> input_array = np.random.randint(1000, size=(32, 10)) >>> model.compile('rmsprop', 'mse') >>> output_array = model.predict(input_array) >>> print(output_array.shape) # (32, 10, 64)  

الخوارزمية الجشعة هي الخوارزمية التي تبني الحل خطوة خطوة أو قطعة قطعة وتعتمد على اختيار الخيار الأمثل (يعظم الربح) عند كل نقطة اختيار, أي أنها تخلق خيار مثالي محلي على أمل أن هذا السلوك سيقودنا الى حل مثالي شامل (أي حل مثالي لكامل المسألة).
كما أنه لا يمكننا اثبات صحة حل مسألة تعتمد على الخوارزمية الجشعة ولكن يكفي إعطاء مثال لإثبات أن الخوارزمية خاطئة. لنأخذ المثال التالي ولنحاول حلها بطريقة الخوارزمية الجشعة:
لنفرض لدينا قاعة وعدد من المقررات التي نريد اعطاء محاضرة منها في هذه القاعة مع توقيت بداية و نهاية كل من هذه المحاضرات والمطلوب ما هو أكبر عدد من الأنشطة او المحاضرات التي نستيطع القيام بها في هذه القاعة؟
تذكر أن يكفي إعطاء مثال لاثبات ان الخوارزمية خاطئة.
1_سنحاول حل هذه المسألة بختيار الأنشطة ذات الامتداد الزمني(توقيت النهاية-توقيت البداية) الأقصر,ولكن هذه الفكرة خاطئة ويمكن اعطاء هذا المثال لاثبات ذلك: النشاط الاول من 8 الى 11. النشاط الثاني من 10:30 الى 12. النشاط الثالث من 11:30 الى 3. بناءان على الفكرة السابقة سيتم اختيار النشاط الثاني فقط بينما من الأفضل اختيار النشاطين الأول و الثالث.
2_سنحاول هذه المرة باختيار الأنشطة ذات الزمن البداية الأصغر,ولكن هذه الفكرة خاطئة ايضا ويمكن اعطاء هذا المثال لأثبات ذلك:
النشاط الأول من 8 الى 1. النشاط الثاني من 9 الى  10. النشاط الثالث من 10 الى 11. النشاط الرابع  من 11:30 الى  12:30
بناءان على الفكرة السابقة سيتم اختيار النشاط الأول فقط بينما من الأفضل اختيار النشاط الثاني و الثالث و الرابع. إذاً ما هي فكرة حل هذه المسألة؟
يتم حل هذه المسألة بأخذ الأحداث التي تنتهي أولا مع مراعاة عدم تداخل تواقيتها، أي أقوم بترتيب الأنشطة حسب زمن انتهائها (من النشاط الذي ينتهي أولا الى النشاط الذي ينتهي اخيرا) ثم أقوم بأخذ النشاط الذي ينتهي أولا و من ثم أبحث عن اول نشاط يبدأ بعد انتهائه(كي لا يحدث تداخل في تواقيت الأنشطة) ومن ثم أبحث عن أول نشاط يبدأ بعد انتهاء أخر نشاط أخذناه وهكذا...
ويكون pseudocode الخاص بالمسألة كالتالي:
input: n activities output: a max size subset of compatible activities sort activities by increasing finish time A1,A2,A3 where F1<F2<F3<..<Fn E<-{1} T<-F1 for i=2 to n do { if(Si>=T)then { add i to E T<-Fi } } output E  

بشكل افتراضي وتلقائي، يتم تشغيل طبقة التضمين على ال GPU في حال كانت متوفرة، من أجل الحصول على أفضل أداء، هذا يعني أن مصفوفة التضمين "embedding matrix"ستم وضعها في ال GPU وهنا قد تنتج المشكلة في حال كانت مصفوفة التضمين ضخمة وبالتالي لايمكن عمل fitting لها في ال GPU فيظهر هذا الخطأ، ولحل هذه المشكلة يجب أن تقوم بوضعها في ال "CPU memory" ويمكنك القيام بذلك بالشكل التالي:
with tf.device('cpu:0'): embedding_layer = Embedding(...) embedding_layer.build() ثم بعد ذلك يمكنك أن تضيفها إلى نموذجك بالشكل التالي:
model.add(embedding_layer) # Wherever_there_is_artificial_intelligence,_there is me

في مسائل التصنيف المتعدد يجب أن تكون حذراً مع اختيار دالة الخسارة، والمشكلة هنا هي في اختيارك لدالة الخسارة، فعندما تكون بيانات y_true مرمزة بترميز One-Hot يجب أن نختار categorical_crossentropy أما إذا كانت بيانات y_true تتبع ترميزاً عادياً (أي كل صنف تم تمثيله بعدد صحيح 1,2,3...,class_n) فهنا يجب أن نختار دالة الخسارة sparse_categorical_crossentropy.

بما أنه لديك 3 أصناف فيجب أن تقوم بتحويل ال y_train و y_test إلى الترميز الفئوي أي One-Hot أي:
from keras.utils import to_categorical y_test = to_categorical(y_test, 4) y_train = to_categorical(y_train, 4) وأيضاً يجب أن تتحقق من أبعاد المدخلات لديك في طبقة LSTM حيث أن الدخل المتوقع لهذه الطبقة يجب أن يكون:
(batch_size, timesteps, input_dim) # 3D tensor  

الخطأ هو  أن شكل الخرج Y في البيانات هو (,60000) يجب أن يكون شكل الخرج في البيانات مطابق لشكل الخرج في الموديل حيث شكل الخرج في الموديل الذي تقوم بتدريبه هو (32,2) وشكل المخرجات التي تظهر في خرج البيانات باعتبار انها 0 أو 1 هو (32,1) لذلك يجيب تغير الموديل لإخراج قيمة واحدة بدلاً من 2 واستخدام تابع التفعيل sigmoid مع تابع الخسارة binary_crossentropy
أي يصبح الكود كالتالي:
import numpy as np import pandas as pd from keras.models import Sequential from keras.layers import Dense , Activation, Dropout 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() y_train[y_train<=5]=0 y_train[y_train>5]=1 y_train=y_train.astype('int64') print(x_train.shape, y_train.shape) image_size = x_train.shape[1] input_size = image_size * image_size x_train = np.reshape(x_train, [-1, input_size]) x_train = x_train.astype('float32') / 255 x_test = np.reshape(x_test, [-1, input_size]) x_test = x_test.astype('float32') / 255 batch_size = 32 hidden_units = 256 model = Sequential() model.add(Dense(hidden_units, input_shape=(input_size,))) model.add(Activation('relu')) model.add(Dropout(0.45)) model.add(Dense(hidden_units)) model.add(Activation('relu')) model.add(Dropout(0.45)) #إصلاح model.add(Dense(1)) #إصلاح model.add(Activation('sigmoid')) #إصلاح model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(x_train, y_train, epochs=5, batch_size=batch_size)  

أنت قمت بتعيين الطبقة الأولى بحيث تتوقع منك أبعاد الإدخال (،300) عن طريق ضبطك للوسيط input_shape على input_shape = (300،) ثم أعطيت النموذج لاحقاً أبعاداً مختلفة مساوية لأبعاد البيانات التي تريد التدريب عليه، وهذا خاطئ.
الوسيط input_shape يحدد أبعاد المدخلات للطبقة، لذا يجب أن يكون مطابقاً لأبعاد بياناتك.
لحل المشكلة استخدم train_data.shape[1] أي تصبح input_shape=(train_data.shape[1],) بدلاً من تحديد الأبعاد بشكل يدوي أي بدلاً من
(,input_shape = (300:
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="mse", metrics=['mae']) #بالشكل التالي compile هنا استخدمناها كدالة تكلفة وكمعيار عن طريق تمريره إلى الدالة #model.compile(optimizer='rmsprop', loss='mse', metrics=['mse']) return model # تدريب النموذج model = build_model() model.fit(train_data, train_targets,epochs=8, batch_size=64)  

يمكنك القيام بذلك من خلال التابع format في المكتبة locale كالتالي:
import locale locale.format("%d", 123456789 , grouping=True)# '123,456,789' أو باستخدام التعابير المنطقية من مكتبة regex:
import re re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%d" % 123456789) # '123,456,789' أوكما أشار الأستاذ سمير في إجابته:
x=123456789 '{:0,.2f}'.format(x) # '123,456,789.00' يمكنك أيضاً القيام بذلك بشكل يدوي  من خلال التابع التالي:
def sp(x): l = [] g = '%d' % x while g and g[-1].isdigit(): l.append(g[-3:]) g = g[:-3] return g + ','.join(reversed(l)) sp(123456789) # '123,456,789'  

الطريقة WaitAll():
 هي طريقة ستاتيكية تستدعى لأجل الصف، دخلها مصفوفة عناصر من النمط Task، مهمتها إيقاف الأب، مثلاً لو استدعيناها في ال mian سيتم إيقافه (ينتظر) حتى تنفيذ كل التاسكات الموجودة ضمن هذه المصفوفة فقط .
مثال :
هنا مثال عن الطريقة فقط ، باعتبار الصف Test  صف يحوي طريقتين وهما MethodA تقوم بطباعة A خمسين مرة، والطريقة MethodB تطبع B خمسين مرة:
var TaskA = new Task.Factory.StartNew(Test.MethodA); var TaskB = new Task.Factory.StartNew(Test.MethodB); Task [] stopmain = { TaskA , TaskB }; Task.WaitAll(stopmain); هنا سيتوقف ال  main  حتى يتم تنفيذ جميع ال task في المصفوفة stopmain.
For (int i=0 ; i<50;i++){ console.WriteLine("Main");} الخرج : طباعة A و B خمسين مرة بشكل متداخل(ترتيب غير معلوم) ومن ثم طباعة Main خمسين مرة.
الطريقة WaitAny()  :
هي أيضا طريقة ستاتيكية و تقبل مصفوفة تاسكات كسابقتها اذاً هي شبيها بالطريقة السابقة ولكن لو استدعيناها في ال main مثلاً لن تنتظر انتهاء كل التاسكات، بل تنتظر انتهاء أول task وعند اكتمال تنفيذ هذا التاسك يستأنف ال main العمل بالتوازي مع التاسكات الأخرى
مع الملاحظة أن هذه الطريقة ترد قيمة وهي index يمثل موقع التاسك الذي انتهى من المصفوفة.
مثال :
var TaskA = new Task.Factory.StartNew(Test.MethodA); var TaskB = new Task.Factory.StartNew(Test.MethodB); Task [] stopmain = new Task[] { TaskA , TaskB }; Int id = Task.WaitAny(stopmain); هنا سيتوقف ال  main  حتى يتم تنفيذ إحدى تاسكات المصفوفة  لا على التعيين و ترد هذه الطريقة ال index للتاسك الذي اكتمل تنفيذه أولاً إلى المتحول id ، حيث أن المصفوفة هنا تحوي عنصرين فال index إما 0 أو 1.
For (int i=0 ; i<50;i++){ console.WriteLine("Main");} الخرج :
طباعة A خمسين مرة و طباعة B خمسين مرة بترتيب غير معلوم ولكن طباعة   الكلمة main لا تبدأ إلا بعد انتهاء طباعة إحدى العبارات "ِA" أو "B".

Hinge loss هي دالة تكلفة تستخدم لمصنفات التدريب مثل SVM
تقوم هذه الدالة بحساب خسارة هاينغ بين القيم المتوقعة والقيم الحققية للنموذج.
يتم استخدامها عبر الموديول:
keras.losses loss = maximum(1 - y_true * y_pred, 0) مثال:
y_true = [[1., 0.], [0., 0.]] y_pred = [[0.3, 0.5], [0.2, 0.6]] h = tf.keras.losses.Hinge() h(y_true, y_pred).numpy() لاستخدامها في تدريب نموذجك نقوم بتمريرها إلى الدالة compile كالتالي:
model.compile( loss=keras.losses.hinge(), ... ) # أو model.compile( loss="hinge", ... )
سأعطي الآن مثال لاستخدمها في بناء نموذج في في كيراس يحاكي خوارزمية SVM:
#SVM النموذج التالي يعمل بشكل مشابه لل #RandomFourierFeatures نقوم باستخدام طبقات SVM لتحقيق from tensorflow.keras.layers.experimental import RandomFourierFeatures from tensorflow import keras from keras.datasets import mnist from tensorflow.keras import layers (x_train, y_train), (x_test, y_test) =mnist.load_data() # معالجة البيانات x_train = x_train.reshape(-1, 784).astype("float32") / 255 x_test = x_test.reshape(-1, 784).astype("float32") / 255 y_train = keras.utils.to_categorical(y_train) y_test = keras.utils.to_categorical(y_test) # بناء النموذج model = keras.Sequential( [ keras.Input(shape=(784,)), RandomFourierFeatures( output_dim=4096, scale=10.0, kernel_initializer="gaussian" ), layers.Dense(units=10), ] ) model.compile( optimizer="rmsprop", loss=keras.losses.hinge(), metrics=["acc"], ) # تدريب النموذج model.fit(x_train, y_train, epochs=2, batch_size=64, validation_split=0.2)  

ببساطة ال destructor  عبارة عن تابع لا يرد أية  قيمة ولا يحوي على  return ولا نمرر له أي وسيط.
يتم تعريفه بأن نكتب ( اسم الصف مسبوق بالإشارة  ~ ) ثم فتح قوسين فارغين، و من الممكن أن يحوي تعليمات أو أن لا يحوي.
مثال :
Class A{ Public : // تعريف باني افتراضي A() { cout<<"A"; } // destructor ~ A() { cout<<" Destructor is call " ; } } لكل صف يتم إنشاؤه يكون هناك destructor افتراضي (يتم تعريفه تلقائياً حتى ولو لم تقم بالتصريح عنه واستدعائه ).
مثلاً في حال تم انشاء كائن ضمن دالة وتم تنفيذ محتوى هذه الدالة سيتم استدعاء التابع  destructor (وببساطة سيتم حذف أي شيء تم تعريفه ضمن الدالة بعد أن تنفذ).
يتم الاستفادة من التابع destructor عندما يكون ضمن الصف حقول معطيات ديناميكية مثل (مؤشرات ، مصفوفات ديناميكية ..إلخ) حيث أننا ضمن جسم التابع نقوم بتحرير المواقع المحجوزة من قبل هذه المتحولات الديناميكية عن طريق استخدام التعليمة  delete.
مثال :
ليكن لدينا الصف dynamic يحتوي على المصفوفة الديناميكية A ،من النمط  int  و باني افتراضي للتهيئة بالصفر وطريقة لإدخال عناصر المصفوفة و هادم ( destructor).
عندئذ يجب استخدام التعليمة  delete في الهادم لتحرير المواقع المحجوزة من قبل المصفوفة الديناميكية.
#include <iostream> using namespace std; class dynamic { private : int *A ; int size ; public : // البان الافتراضي dynamic (){ cout<<" constructor is called " ; size = 0; A=new int [0]; } //طريقة لادخال عناصر المصوفة void input(s){ size = s; A=new int [size]; for (int i=0;i<size;i++){ cin>>A[i]; } //هادم لتحرير الذاكرة ~dnamic() { Cout<< " destructor is called " ; Delete[]A; } }; int main() { dynamic d //غرض من الصف السابق int n; cin>>n ; //ادخال عدد العناصر d.input(n); return 0 ; } //الخرج constructor is called 5 1 2 55 57 69 destructor is called إذاً تم استدعاء التابع Destructor بعد الانتهاء من تنفيذ جميع تعليمات البرنامج الموضوعة ضمن ال main، ليقوم بتحرير المواقع المحجوزة.

هي دالة خسارة (تكلفة) وتستخدم لنماذج التوقع، وهو يمثل متوسط مجموع الفروق بين القيم الحقيقية والمتوقعة بالقيمة المطلقة.
loss = abs(y_true - y_pred) يعد MAE مفيدًا في حالة تلف بيانات التدريب بسبب القيم المتطرفة (أي أننا نتلقى بشكل خاطئ قيمًا سلبية / إيجابية ضخمة بشكل غير واقعي في بيئة التدريب لدينا ، ولكن لانتلقاها في بيئة الاختبار).
بشكل عام لا أحبذ استخدامه كدالة تكلفة لأن الدوال من الشكل |x| أي دوال القيمة المطلقة يكون لها شكل مشابه تماماً لحرف V وبالتالي فإن قيمة المشتقة في أي نقطة ستكون كبيرة وهذا أمر غير مناسب، ويمكن إصلاح هذه المشكلة لكن لاداعي لإضاعة الوقت عليها، حيث يمكنك استخدام MSE فهي دالة ممتازة مع مهام التوقع.
إن أفضل ايستخدام لها بالنسبة لي هو استخدامها كمعيار (مقياس) لأداء نماذج التوقع.
في المثال التالي سأقوم باستخدامها كدالة خسارة وكمعيار:
# تحميل الداتا 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=keras.losses., metrics=['mae']) #بالشكل التالي compile هنا استخدمناها كدالة تكلفة وكمعيار عن طريق تمريره إلى الدالة model.compile(optimizer='rmsprop', loss='mae', metrics=['mae']) return model # تدريب النموذج model = build_model() model.fit(train_data, train_targets,epochs=8, batch_size=64)

 

Log-cosh هي دالة أخرى من دوال التكلفة المستخدمة مع مهام التوقع  وهي أكثر سلاسة من MSE، وهي لوغاريتم جيب التمام الزائدي لخطأ التنبؤ "hyperbolic cosine of the prediction error".
log(cosh(x)) تساوي تقريباً:
(x ** 2) / 2 #صغيرة x عندما تكون abs(x) - log(2) # عندما تكون كبيرة هذا يعني أنها تعمل في الغالب مثل MSE، ولكنها لا تتأثر بالتنبؤ غير الصحيح إلى حد كبير. ولديها كل مزايا دالة هوبر، إضافة إلى إمكانية تفاضلها مرتين، على عكس دالة هوبر. وهذا مهم مع العديد من الخوارزميات التحسين مثل Newton’s.
في كيراس يمكن استخدامها من الموديول:
keras.losses الصيغة الرياضية:
# logcosh = log((exp(x) + exp(-x))/2); x= y_pred - y_true مثال:
import keras y_true = [[0., 1.], [0., 0.]] y_pred = [[1., 1.], [0., 0.]] l = keras.losses.LogCosh() l(y_true, y_pred).numpy() # 0.1084452 ولاستخدامها في نموذجك نمررها إلى الدالة compile كالتالي:
model.compile( loss='LogCosh' ... ) # أو model.compile( loss=keras.losses.LogCosh() ... ) مثال عملي:
# تحميل الداتا 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='LogCosh', metrics=['mae']) return model # تدريب النموذج model = build_model() model.fit(train_data, train_targets,epochs=8, batch_size=64) -----------------------------------------------------------------------Epoch 1/8 7/7 [==============================] - 1s 5ms/step - loss: 21.0908 - mae: 21.7840 Epoch 2/8 7/7 [==============================] - 0s 6ms/step - loss: 20.3744 - mae: 21.0669 Epoch 3/8 7/7 [==============================] - 0s 4ms/step - loss: 18.8925 - mae: 19.5840 Epoch 4/8 7/7 [==============================] - 0s 2ms/step - loss: 17.1608 - mae: 17.8454 Epoch 5/8 7/7 [==============================] - 0s 3ms/step - loss: 16.1519 - mae: 16.8398 Epoch 6/8 7/7 [==============================] - 0s 3ms/step - loss: 14.0706 - mae: 14.7509 Epoch 7/8 7/7 [==============================] - 0s 3ms/step - loss: 13.2366 - mae: 13.9173 Epoch 8/8 7/7 [==============================] - 0s 3ms/step - loss: 11.4787 - mae: 12.1537  

حسناً اعتدنا على تمرير وسيطين إلى طبقة التضمين، الأول هو عدد ال tokens (المفردات) الموجودة في بياناتك أي (1 + maximum word index) والثاني هو dimensionality of the embeddings أي أبعاد التضمين. وكان ذلك كافياً عندما تكون الطبقة التالية هي طبقة تكرارية (أحد أنواع RNN).
لكنك هنا تستخدم طبقة Flatten بعدها، لذا في هذه الحالة يجب أن نقوم بتمرير وسيط إضافي إلى طبقة التضمين وهو input_length أي طول سلاسل الإدخال لديك:
from keras.datasets import imdb from keras.layers import Embedding, SimpleRNN,Flatten,Dense from keras.models import Sequential (input_train, y_train), (input_test, y_test) = imdb.load_data( num_words=10000) print(len(input_train), 'train sequences') print(len(input_test), 'test sequences') ################ نضيف################### from keras.preprocessing import sequence maxlen = 20 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 model = Sequential() model.add(Embedding(10000, 16, input_length=maxlen)) model.add(Flatten()) model.add(Dense(32, activation='relu')) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) history = model.fit(input_train, y_train, epochs=2, batch_size=32, validation_split=0.2) --------------------------------------------------------------------------------------------- 25000 train sequences 25000 test sequences Pad sequences (samples x time) input_train shape: (25000, 20) input_test shape: (25000, 20) Epoch 1/2 625/625 [==============================] - 2s 3ms/step - loss: 0.6506 - acc: 0.5996 - val_loss: 0.5080 - val_acc: 0.7414 Epoch 2/2 625/625 [==============================] - 2s 3ms/step - loss: 0.4356 - acc: 0.7957 - val_loss: 0.4968 - val_acc: 0.7534  

المشكلة تحدث في طبقة التضمين Embedding.
هذه الطبقة تأخذ وسيطين على الأقل الأول هو عدد ال tokens (المفردات) الموجودة في بياناتك أي (1 + maximum word index) والثاني هو dimensionality of the embeddings أي أبعاد التضمين.
يمكن اعتبار طبقة التضمين قاموس يقوم بربط أعداد صحيحة (كل عدد يمثل كلمة) بأشعة كثيفة.
"maps integer indices,(which stand for specific words) to dense vectors"
وبالتالي يأخذ كمدخل له عدد صحيح ثم يبحث عن هذا العدد في قاموسه ثم يرد الشعاع المقابل له.
Word index --> Embedding layer --> Corresponding word vector 
أنت ماذا فعلت؟! أنت قمت بتحديد عدد المفردات بالنص الخاص بك إلى 75000 كلمة فريدة، ثم قمت بتحديد 10000 كلمة في طبقة التضمين وهذا سينتج خطأ لأن الكلمات الموجودة في بياناتك أكثر بكثير وبالتالي لن يجد هذه الكلمات في قاموسه الداخلي وبالتالي ينتج خطأ.
لحل المشكلة يجب أن تتم مطابقتهما أي إذا حددت عدد الكلمات التي ستبقى في نصك في مرحلة ال tokenaization ب 75000 فيجب أن تحدد 75000 في طبقة التضمين أيضاً.
التصحيح:
df_train = pd.read_csv('/content/drive/MyDrive/imdbdataset/Completely_clean_data.csv') df_train.drop(df_train.filter(regex="Unname"),axis=1, inplace=True) df_test = pd.read_csv('/content/drive/MyDrive/imdbdataset/Completely_clean_data_test.csv') df_test.drop(df_test.filter(regex="Unname"),axis=1, inplace=True) max_words = 75000 tokenizer = Tokenizer(num_words=max_words) # fitting tokenizer.fit_on_texts(pd.concat([df_test['review'], df_train['review']])) #max_len=int(df["review_len"].mean()) #231 # do you remember!! train = tokenizer.texts_to_sequences(df_train['review']) test = tokenizer.texts_to_sequences(df_test['review']) train = pad_sequences(train, maxlen=200) test = pad_sequences(test, maxlen=200) print("the shape of data train :",train.shape) print("the shape of data test :",test.shape) # model def modelBiLSTM(): max_words = 75000 #drop_lstm =0.4 embeddings=128 model = Sequential() # الإصلاح model.add(Embedding(max_words, embeddings)) model.add(Bidirectional(LSTM(64, activation='tanh'))) # 2D output model.add(Dense(1, activation='sigmoid')) # binary output return model model=modelBiLSTM() model.summary() # training model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) history=model.fit(train, train_label,validation_split=0.12, batch_size=32, epochs=8)