Ali Haidar Ahmad

إن الخطوة الأخيرة التي تسبق تغذية شبكتك العصبية بالبيانات هي توحيد طول السلاسل، حتى لو كنت تستخدم أي نوع من الشبكات يجب القيام بهذه الخطوة (لكن تختلف طريقة التوحيد تبعاُ لنوع ترميزك طبعاً وهنا نستخدم word-embedding ,وهي الطريقة الأكثر فعالية طبعاً). كما أشرت فإن السلاسل النصية تكون بأطوال مختلفة وهذا أمر غير مقبول لأن طبقة التضمين تتوقع منك مصفوفة ثنائية الأبعاد تحديداً numpy array ثم تحولها تلقائياً (من دون تدخلك) إلى tensor، لكن لايمكن لل tensor أن تكون بأبعاد مختلفة وإنما يجب أن تكون بأبعاد محددة وثابتة ولهذا السبب نقوم بعملية حشو و قطع للسلاسل النصية في بياناتنا، بحيث نحدد طول معين نريده وليكن 50 ثم نمر على كل السلاسل في بياناتنا، وكل سلسلة أطول من 50 نقوم بقطعها (أي نأخذ أول 50 كلمة فقط)، وكل كلمة أقصر من 50 نقوم بحشوها بأصفار، وهذا تماماً مايقوم له التابع الجميل الذي اسمه pad_seq في كيراس وتنسرفلو إليك الحل: from keras.datasets import imdb from keras import preprocessing max_features = 10000 maxlen = 20 (x_train, y_train), (x_test, y_test) = imdb.load_data( num_words=max_features) x_train = preprocessing.sequence.pad_sequences(x_train, maxlen=maxlen) # هنا حددنا طول الكلمات ب 20 x_test = preprocessing.sequence.pad_sequences(x_test, maxlen=maxlen) # بناء نموذجك from keras.models import Sequential from keras.layers import Flatten, Dense model = Sequential() model.add(Embedding(10000, 8, input_length=maxlen)) model.add(Flatten()) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) model.summary() # تدريبه history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2)

النموذج الذي قمت بتصديره هو من tensorflow.keras وليس من keras API مباشرة. وهما مختلفان رغم أنهما بنفس الاسم (الكثيرين يخلطون بينهم وهذا خاطئ). لذلك أثناء تحميله ، قد يتم استخدام tf.ragged tensors التي قد لا تكون متوافقة مع keras API. لذا فالحل يكون بأن لا تستورد keras مباشرة من keras api وإنما من tensorflow.keras أي قم بتبديل: from keras.preprocessing.image import img_to_array from keras.models import load_model إلى from tensorflow.keras.preprocessing.image import img_to_array from tensorflow.keras.models import load_model

السبب الرئيسي لاستخدام NaN بدلاً من None هو أنه يمكن تخزينه باستخدام نوع float64 لـ numpy ، بدلاً من نوع object الأقل كفاءة. حيث أن عملية تخزينه على شكل object سوف يجعله غير قابل للتعامل مع عمليات نمباي . بينما NaN يمكن استخدامها كقيمة عددية في العمليات الحسابية وأيضاً في العمليات التي يمكن تطبيقها باستخدام مكتبة نمباي.

نعم هناك فرق وكل نوع منهما يستخدم مع أنواع محددة. حيث إن عملية الفلترة تهدف لإزالة الضجيج من صورة ما، وهناك نوعين أساسيين للضجيج: ضجيج خطي وضجيج غير خطي .ولكل نوع منهما طريقة لإزالته فالخطي تتم إزالته بمرشحات خطية مثل ال mean filter أو gaussian filter واللاخطي بمرشحات لاخطية مثل median filter و max filter و min filter. لذا فإن أول مرحلة هي معرفة أو دراسة نوع الضجيج حيث نقوم بحساب ال 𝑥̅, 𝑆𝑇𝐷 ومقارنة قيمتهما، حيث أن المتوسط الحسابي للصورة 𝑥̅، والانحراف المعياري للصورة STD. وهنا نميز حالتان، الأولى عندما تكون قيمة الانحراف المعياري قريبة من قيمة المتوسط الحسابي وهذا يعني أن: 1.الصورة لديها تفاصيل كثيرة (كميات كبيرة من المعلومات) 2. في هذه الحالة نعتبر الانحراف المعياري واقع في جوار المتوسط الحسابي. 3.قيمة النحراف المعياري لا تعبر عن نسبة الخطأ في الصورة لوجود قيم كبيرة مقارنة بقيم أخرى أي أن لدينا حالة تسمى "Extrime values". أما الحالة الثانية عندما تكون قيمة الانحراف المعياري أكبر بكثير من المتوسط الحسابي وهنا يكون لدينا: 1.تفاصيل قليلة في الصورة. 2. قيمة الانحراف المعياري تعبر عن نسبة الخطأ في الصورة وتباعد قيمها عن بعضها. 3. بيانياً تأخذ شكل أسنان المنشار أو بمعنى آخر تكون قيم ال intensity value متقاربة. ثم علينا معرفة فيما إذا كانت الصورة تتبع توزيعاً غاوصياً أم لا، وعلى هذين الأساسين يتم تحديد نوع الضجيج. فالضجيج الخطي هو توزع غير طبيعي بحيث يوجد قيم داخل القبّة (داخل الجرس) و قيم خارجها وبحيث يكون 𝑥̅≅𝑆𝑇𝐷 ،وشكله عبارة عن اهتراءات بالصورة أو تكون الحواف غير واضحة، وتتم إزالته بفلاتر خطية و هي عملية تسمى بال Smothing أو blurring أي التنعيم ويستخدم عادة لإزالة الضجيج الغاوصي من الصورة (ضجيج مجهول السبب وهو عبارة عن سويات رمادية تضاف إلى الصور وتسلك سلوك تابع غاوص في توزعها وتأثيره كتنميش في الصورة أو اهتراءات كما ذكرت). أما الضجيج اللاخطي فهو توزع غير طبيعي بحيث تكون كل القيم خارج تابع الجرس وبحيث يكون 𝑥̅≫𝑆𝑇𝐷 ،وشكله عبارة عن نقاط بيضاء (نقاط فاتحة) في محيط داكن أو سوداء (في محيط فاتح) متوزعة على الصورة ولهذا السبب يسمى بضجيج الملح و الفلفل salt&pepper، وتتم إزالته بفلاتر غير خطية. يمكنك البحث على جوجل لترى أمثلة عن هذين النوعين من الضجيج، فقط قم بكتابة Salt & pepper noise و Gaussian noise

إن معيار قياس كفاءة النموذج الذي تستخدمه لنموذجك هو metrics=['accuracy'] وهو يتوافق مع مهام التصنيف، والمهمة التي لديك هي مهمة توقع لذا يجب عليك استخدام معيار يتناسب مع نوع المهمة مثل MSE أو MAE وبالتالي يجب يصبح الكود كالتالي: from keras.datasets import boston_housing (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 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,activation=None)) model.compile(optimizer='rmsprop', loss='mse', metrics=['mae']) history = model.fit(train_data, train_targets,epochs=7, batch_size=1, verbose=1) ----------------------------------------------------------------------------- Epoch 1/7 404/404 [==============================] - 1s 1ms/step - loss: 309.4995 - mae: 14.3059 Epoch 2/7 404/404 [==============================] - 0s 1ms/step - loss: 29.8972 - mae: 3.6916 Epoch 3/7 404/404 [==============================] - 0s 1ms/step - loss: 19.3192 - mae: 3.0052 Epoch 4/7 404/404 [==============================] - 0s 1ms/step - loss: 11.1953 - mae: 2.4848 Epoch 5/7 404/404 [==============================] - 0s 1ms/step - loss: 12.8683 - mae: 2.5286 Epoch 6/7 404/404 [==============================] - 0s 1ms/step - loss: 14.1816 - mae: 2.5489 Epoch 7/7 404/404 [==============================] - 0s 1ms/step - loss: 9.3017 - mae: 2.1364 أهم معايير قياس كفاءة النماذج في كيراس وتنسرفلو: Keras Regression Metrics: Mean Squared Error: mean_squared_error, MSE or mse Mean Absolute Error: mean_absolute_error, MAE, mae Mean Absolute Percentage Error: mean_absolute_percentage_error, MAPE, mape Cosine Proximity: cosine_proximity, cosine Keras Classification Metrics Binary Accuracy: binary_accuracy, acc Categorical Accuracy: categorical_accuracy, acc Sparse Categorical Accuracy: sparse_categorical_accuracy

predict_classes متوفر فقط من أجل البنية (أو الصف) Sequential ولكنه غير متوفر من أجل الصف Model لذا فالحل هو استخدام التابع predict والتي سيكون خرجها شعاع من التوقعات الاحتمالية، ثم يمكنك بعدها استخدام التابع argmax من مكتبة نمباي لقصر القيم كالتالي: np.argmax(y_pred,axis=1)

يمكنك حساب كفاءة نماذجك خلال التدريب وبعد الانتهاء من التدريب باستخدام المعيار Accuracy، لكن أود لفت انتباهك إلى الأمر التالي، لكي لاتقع في شرك الخطأ الشائع لدى المبتدئين وهو أن هذا المعيار يستخدم فقط لمهام التصنيف ولايستخدم في مهام التوقع أيضاً ملاحظة أخرى لاتعتمد على هذا المعيار إلى في حال كانت البيانات لديك متوازنة ففي حال كانت غير متوازنة ستكون النتائج مضللة تماماً في أغلب الأحيان (نلجأ لمعايير أخرى مثل f1score). إن هذا المعيار يقوم بحساب عدد المرات التي تتطابق فيها القيم المتوقعة مع القيم الحقيقية للبيانات ويعطيك الخرج على شكل قيمة عشرية ضمن المجال 0 إلى 1 بحيث 0 تكافئ 0 حالات تطابق و 1 تكافئ 100% حالات التطابق. لاستخدامها خلال عملية التدريب نقوم بتمريرها إلى الدالة compile كالتالي: model.compile( metrics=["accuracy"]) # أو acc ... ) ولاستخدامها في نهاية التدريب (من أجل حساب الدقة على بيانات الاختبار): acc=model.evaluate(x_test, y_test) print("Test loss:", acc[0]) # الخطأ print("Test accuracy:", acc[1]) # الدقة في المثال التالي سأعرض كيفية استخدامه لقياس الدقة خلال التدريب وبعده على مجموعة بيانات لتصنيف صور الأرقام المكتوبة بخط اليد: import numpy as np from tensorflow import keras from tensorflow.keras import layers num_classes = 10 input_shape = (28, 28, 1) # تحميل البيانات (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() # تقييس البيانات وجعلها ضمن المجال من 0 إلى 1 x_train = x_train.astype("float32") / 255 x_test = x_test.astype("float32") / 255 # Make sure images have shape (28, 28, 1) x_train = np.expand_dims(x_train, -1) x_test = np.expand_dims(x_test, -1) print("x_train shape:", x_train.shape) print(x_train.shape[0], "train samples") print(x_test.shape[0], "test samples") # الترميز الفئوي للبيانات y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) """ x_train shape: (60000, 28, 28, 1) 60000 train samples 10000 test samples """ # بناء النموذج model = keras.Sequential( [ keras.Input(shape=input_shape), layers.Conv2D(32, kernel_size=(3, 3), activation="relu"), layers.MaxPooling2D(pool_size=(2, 2)), layers.Conv2D(64, kernel_size=(3, 3), activation="relu"), layers.MaxPooling2D(pool_size=(2, 2)), layers.Flatten(), layers.Dropout(0.5), layers.Dense(num_classes, activation="softmax"), ] ) model.summary() """ Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d (Conv2D) (None, 26, 26, 32) 320 _________________________________________________________________ max_pooling2d (MaxPooling2D) (None, 13, 13, 32) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 11, 11, 64) 18496 _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 5, 5, 64) 0 _________________________________________________________________ flatten (Flatten) (None, 1600) 0 _________________________________________________________________ dropout (Dropout) (None, 1600) 0 _________________________________________________________________ dense (Dense) (None, 10) 16010 ================================================================= Total params: 34,826 Trainable params: 34,826 Non-trainable params: 0 _________________________________________________________________ """ # تدريب النموذج batch_size = 128 epochs = 15 model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"]) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1) """ Epoch 1/15 422/422 [==============================] - 13s 29ms/step - loss: 0.7840 - accuracy: 0.7643 - val_loss: 0.0780 - val_accuracy: 0.9780 Epoch 2/15 422/422 [==============================] - 13s 31ms/step - loss: 0.1199 - accuracy: 0.9639 - val_loss: 0.0559 - val_accuracy: 0.9843 Epoch 3/15 422/422 [==============================] - 14s 33ms/step - loss: 0.0845 - accuracy: 0.9737 - val_loss: 0.0469 - val_accuracy: 0.9877 Epoch 4/15 422/422 [==============================] - 14s 33ms/step - loss: 0.0762 - accuracy: 0.9756 - val_loss: 0.0398 - val_accuracy: 0.9895 Epoch 5/15 422/422 [==============================] - 15s 35ms/step - loss: 0.0621 - accuracy: 0.9812 - val_loss: 0.0378 - val_accuracy: 0.9890 Epoch 6/15 422/422 [==============================] - 17s 40ms/step - loss: 0.0547 - accuracy: 0.9825 - val_loss: 0.0360 - val_accuracy: 0.9910 Epoch 7/15 422/422 [==============================] - 17s 41ms/step - loss: 0.0497 - accuracy: 0.9840 - val_loss: 0.0311 - val_accuracy: 0.9920 Epoch 8/15 422/422 [==============================] - 16s 39ms/step - loss: 0.0443 - accuracy: 0.9862 - val_loss: 0.0346 - val_accuracy: 0.9910 Epoch 9/15 422/422 [==============================] - 17s 39ms/step - loss: 0.0436 - accuracy: 0.9860 - val_loss: 0.0325 - val_accuracy: 0.9915 Epoch 10/15 422/422 [==============================] - 16s 38ms/step - loss: 0.0407 - accuracy: 0.9865 - val_loss: 0.0301 - val_accuracy: 0.9920 Epoch 11/15 422/422 [==============================] - 16s 37ms/step - loss: 0.0406 - accuracy: 0.9874 - val_loss: 0.0303 - val_accuracy: 0.9920 Epoch 12/15 237/422 [===============>..............] - ETA: 7s - loss: 0.0398 - accuracy: 0.9877 """ # تقييم النموذج acc = model.evaluate(x_test, y_test, verbose=0) print("Test loss:", acc[0]) # Test loss: 0.023950600996613503 print("Test accuracy:", acc[1]) # Test accuracy: 0.9922000169754028

هي طريقة أسرع وأكثر كفاءة ولاسيما في توفير الذاكرة للتعامل مع المصفوفات. ولاستخدام numpy.einsum، كل ما عليك فعله هو تمرير "subscript string" أو ما يسمى بالسلسلة المنخفضة كوسيطة أولى، حيث أن ال subscripts تشير إلى أبعاد المصفوفة بحيث كل بعد سيقابل label (مثلاً i أو j)، ثم مصفوفات الإدخال الخاصة بك كوسيط ثاني. لنفترض أن لديك مصفوفتان ثنائيتا الأبعاد ، A و B ، وتريد القيام بضرب المصفوفة. وبالتالي يكون الحل: np.einsum("ij, jk -> ik", A, B) ال subscripts (السلسلة المنخفضة) ij تتوافق مع المصفوفة A بينما تتوافق jk مع المصفوفة B. أيضاً، أهم شيء يجب ملاحظته هنا هو أن عدد الأحرف في كل subscript يجب أن يتطابق مع أبعاد المصفوفة. (على سبيل المثال ، حرفان للمصفوفات ثنائية الأبعاد ، وثلاثة أحرف للمصفوفات ثلاثية الأبعاد ، وهكذا..) وإذا كررت الأحرف بين السلاسل المنخفضة (j في حالتنا) ، فهذا يعني أنك تريد أن يحدث einsum على طول تلك الأبعاد. وبالتالي ، سيتم تخفيضها. (أي أن هذا البعد سوف يختفي). ستكون السلسلة الموجودة بعد -> هي المصفوفة الناتجة. إذا تركتها فارغة، فسيتم جمع كل شيء وإرجاع قيمة عددية كنتيجة لذلك. عدا ذلك ، سيكون للمصفوفة الناتجة أبعاداً وفقاً للسلسلة المنخفضة. في مثالنا ، سيكون ik. هذا أمر بديهي لأننا نعلم أنه بالنسبة لضرب المصفوفة، يجب أن يتطابق عدد الأعمدة في المصفوفة A مع عدد الصفوف في المصفوفة B وهو ما يحدث هنا (على سبيل المثال ، نقوم بترميز هذه المعرفة عن طريق تكرار الحرف j في السلسلة المنخفضة). فيما يلي بعض الأمثلة الأخرى التي توضح استخدام np.einsum وقوتها في تنفيذ بعض عمليات الموتر "tensor array" أو المصفوفات متعددة الأبعاد: # شعاع vec #array([0, 1, 2, 3]) # مصفوفة A """ array([[11, 12, 13, 14], [21, 22, 23, 24], [31, 32, 33, 34], [41, 42, 43, 44]]) """ # مصفوفة أخرى B """ array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]) """ 1. ضرب المصفوفات: np.einsum("ij, jk -> ik", A, B) """ array([[130, 130, 130, 130], [230, 230, 230, 230], [330, 330, 330, 330], [430, 430, 430, 430]]) """ 2. استخراج العناصر على طول القطر الرئيسي: np.einsum("ii -> i", A) #array([11, 22, 33, 44]) 3. ضرب العناصر المتقابلة في مصفوفين: np.einsum("ij, ij -> ij", A, B) """ array([[ 11, 12, 13, 14], [ 42, 44, 46, 48], [ 93, 96, 99, 102], [164, 168, 172, 176]]) """ 4.التربيع: np.einsum("ij, ij -> ij", B, B) """ array([[ 1, 1, 1, 1], [ 4, 4, 4, 4], [ 9, 9, 9, 9], [16, 16, 16, 16]]) """ 5.مجموع العناصر القطرية الرئيسية: np.einsum("ii -> ", A) # 110 6. منقول مصفوفة: np.einsum("ij -> ji", A) """ array([[11, 21, 31, 41], [12, 22, 32, 42], [13, 23, 33, 43], [14, 24, 34, 44]]) """ 7. الضرب الخارجي للأشعة Outer Product : np.einsum("i, j -> ij", vec, vec) """ array([[0, 0, 0, 0], [0, 1, 2, 3], [0, 2, 4, 6], [0, 3, 6, 9]]) """ 8. الضرب الداخلي inner: np.einsum("i, i -> ", vec, vec) #14 9. الجمع على طول المحور 0 أو 1 أي الأسطر أو الأعمدة: # المحور 0 np.einsum("ij -> j", B) #array([10, 10, 10, 10]) # المحور 1 np.einsum("ij -> j", B) #array([10, 10, 10, 10]) 10. مجموع كل العناصر في مصفوفة: np.einsum("ijk -> ", BM) # 480

هي نسخة محسنة من الشبكة العصبية LSTM. تستخدم GRU معلمات تدريب أقل وبالتالي تستخدم ذاكرة أقل، وتنفذ بشكل أسرع وتتدرب بشكل أسرع من LSTM، لكن LSTM أكثر دقة عندما تكون التسلسلات أطول. باختصار ، إذا كان التسلسل كبيراَ أو كانت الدقة مهمة للغاية، فالأفضل هو الانتقال إلى LSTM بينما بالنسبة لاستهلاك أقل للذاكرة وتشغيل أسرع، انتقل إلى GRU. وفي كيراس يمكنك استخدامها كما في المثال التالي الذي يوضح استخدام هذه الطبقة مع مجموعة بيانات imdb لتحليل المشاعر:: # تحميل البيانات وتجهيز الداتا from keras.datasets import imdb from keras.preprocessing import sequence from keras import layers from keras.models import Sequential max_features = 10000 maxlen = 500 (x_train, y_train), (x_test, y_test) = imdb.load_data( num_words=max_features) x_train = [x[::-1] for x in x_train] x_test = [x[::-1] for x in x_test] x_train = sequence.pad_sequences(x_train, maxlen=maxlen) x_test = sequence.pad_sequences(x_test, maxlen=maxlen) # بناء النموذج model = Sequential() model.add(layers.GRU(32), input_shape=(None, float_data.shape[-1])) model.add(layers.Dense(1)) model.compile(optimizer=RMSprop(), loss='mae') history = model.fit_generator(train_gen, steps_per_epoch=500, epochs=40, validation_data=val_gen, validation_steps=val_steps) الصيغة العامة: tf.keras.layers.GRU( units, activation="tanh", recurrent_activation="sigmoid", 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 كما أشرنا.

GitLab هي خدمة شبيهة بـ GitHub توفر الإدارة الداخلية لـ DevOps المستندة إلى الويب لمستودعات Git. يقدم GitLab خيارين: إصدار مجتمع مجاني وإصدار مؤسسة مدفوع. ولاتوجد اختلافات كبيرة بينهم فكلاهما يستخدمان لإدارة وعرض المشاريع. إضافةً إلى ماذكره @محمد أبو عواد هذا ملخص للفروقات: Open source.1: غيت لاب مفتوحة الممصدر، أما غيتهب ليست كذلك. 2. Private Repository: غيت لاب يسمح للمستخدمين بلإنشاء مستودع خاص مجاني، وغيتهب يسمح بذلك أيضاً لكن بحد أقصى 3 متعاونين. 3.Navigation: لاب يوفر ميزة التنقل في المستودع، وهب كذلك. 4.Project Analysis: يوفر للمستخدم رؤية مخططات تطوير المشروع، أما في هب فهي غير متوفرة. 5.Advantages: لاب هو تطبيق سحابي آمن جداً ومفتوح المصدر، هب يتم استخدامه لمشاركة العمل أمام الجمهور، ويساعدنا في إنشاء توثيق منظم للمشروع. 6.Disadvantages: لديه العديد من الأخطاء، هب لديه مستودع محدود ويدعم فقط git. وبشكل أساسي يتمثل الاختلاف الرئيسي بين GitHub و GitLab في النظام الذي تقدمه كل فلسفة. حيث يتمتع GitHub بانتشار أكبر ويركز بشكل أكبر على أداء البنية التحتية، بينما يركز GitLab بشكل أكبر على تقديم نظام قائم على الميزات مع نظام أساسي مركزي ومتكامل لمطوري الويب.

أولاً أحب أن ألفت الانتباه إلى أن الأمر غير مرتبط ب pandas فحتى مع المصفوفات العادية سيسلك نفس السلوك، صحيح أن الأمر قد يربك قليلاً كون أي شخص سيتوقع للمرة الأولى أن axis=1 يجب أن تحسب المتوسط للعمود وليس للسطر كما يحدث، لكن الأمر هنا مختلف ف axis= 0 تشير إلى التجميع على طول الصفوف أما 1 تشير إلى التجميع على طول الأعمدة بشكل أبسط يمكنك القول: axis:يحدد المحور الذي يتم من خلاله حساب المتوسط. المحور 0: سيعمل على جميع الصفوف في كل عمود. أما المحور 1: يعمل على جميع الأعمدة في كل صف. وبشكل افتراضي يحسب المتوسط على كل المصفوفة (عند ضبطه على NONE أي الحالة الافتراضية). كما في المثال: import numpy as np v = [[1,5], [1, 2],[1, 2]] v=np.array(v) """ array([[1, 5], [1, 2], [1, 2]]) """ v.mean(axis=None) # 2.0 v.mean(axis=1) # array([3. , 1.5, 1.5]) v.mean(axis=0) # array([1., 3.])

السبب لهذا الخطأ هو أخطاء في إصدار pandas الذي لديك. تم إطلاق نسخة أحدث من dask للتعامل مع هذا الخطأ قم بتحديث dask. في حال كنت تستخدم بيئة أناكوندا: conda update dask أو: pip install --upgrade dask أو قم بتحديث pandas إلى الإصدار الجديد: conda update pandas # أو pip install --upgrade pandas

حسب اعتقادي فإن مصفوفات نمباي تتعامل مع بيانات المصفوفات الغير متجانسة ك "object" ولايمكنها التعامل معها ك int أو أي نمط آخر، لذا فالحل الوحيد هو حشر قيم في مصفوفتك (أصفار مثلاً)، ويمكنك القيام بذلك من خلال التابع pad_sequences كالتالي: import numpy as np v = [[1], [1, 2]] from keras import preprocessing maxlen=2 v=preprocessing.sequence.pad_sequences(v, maxlen=maxlen) print(v.dtype) # int32 v """ array([[0, 1], [1, 2]]) """

هي تطوير لفكرة الشبكات العصبية المتكررة RNNs بأنواعها المختلفة والفرق هو أن الشبكات العصبية المتكررة ثنائية الاتجاه تربط طبقتين مخفيتين في اتجاهين متعاكسين بنفس الإخراج. وبالتالي يمكن لطبقة الإخراج الحصول على معلومات من حالات الماضي والمستقبل في وقت واحد، وهذا مايجعلها أقوى ولاسيما في التقاط معنى السياق. ويمكن تطبيقها على أي نوع من أنواع الشبكات العصبية المتكررة أحادية الاتجاه مثل RNN أو LSTM أو GRU. ويمكن استخدامها عن طريق تمرير الطبقة أحادية الاتجاه لها فقط كما سأوضح في المثال التالي. 1. مثال لاستخدامها مع LSTM: # تحميل البيانات وتجهيز الداتا from keras.datasets import imdb from keras.preprocessing import sequence from keras import layers from keras.models import Sequential max_features = 10000 maxlen = 500 (x_train, y_train), (x_test, y_test) = imdb.load_data( num_words=max_features) x_train = [x[::-1] for x in x_train] x_test = [x[::-1] for x in x_test] x_train = sequence.pad_sequences(x_train, maxlen=maxlen) x_test = sequence.pad_sequences(x_test, maxlen=maxlen) # بناء النموذج model = Sequential() model.add(layers.Embedding(max_features, 100)) # لاحظ كيف يكون استخدامها حيث نقوم بتمرير الطبقة التي نريدها لها بالشكل التالي model.add(layers.Bidirectional(layers.LSTM(64))) model.add(layers.Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) history = model.fit(x_train, y_train, epochs=8, batch_size=64, validation_split=0.2) 2.مثال لاستخدامها مع GRU بشكل مشابه أيضاً: from keras.models import Sequential from keras import layers from keras.optimizers import RMSprop model = Sequential() model.add(layers.Bidirectional(layers.GRU(32), input_shape=(None, float_data.shape[-1]))) model.add(layers.Dense(1)) model.compile(optimizer=RMSprop(), loss='mae') history = model.fit_generator(train_gen, steps_per_epoch=500, epochs=40, validation_data=val_gen, validation_steps=val_steps) إن الطبقات ثنائية الاتجاه تعطيك أداء أفضل من ناحية الدقة لكنها تستهلك زمن كبير جداً مقارنة بالطبقات أحادية الاتجاه.

لنفهم ال struct دعنا نتابع المثال التالي. لنفرض أنه طلب منك أن تكتب برنامج تسجل فيه سجلات طلاب والذي يحوي بيانات ((( مختلفة )))). مثل (رقم الطالب (int) ، الاسم الأول (string)، الكنية (string)، المعدل (float)) وقد يكون هناك بيانات أخرى.. الآن بالحالة الاعتيادية لكي يتم ذلك، نعرف لكل طالب نعرف متغيرات يعبر كل منها عن نوع من البيانات المذكورة .. مثلاً لو كان لدي طالبين فأنا بحاجة 4 متحولات لكل طالب = 8 متحولات. وبالتالي السؤال الذي يفرض نفسه هنا هو ماذا لو كان لدي 20 طالب مثلاً ؟ سنحتاج 20 ×4 = 80 متحول !! وهذا كما نعلم أمر مقبول أو محبب ! ما الحل إذاً؟ الحل هو struct، إذاً : struct هي بنية معطيات تستخدم لتعريف نوع جديد يحوي مجموعة محددة من القيم مختلفة النوع، ويتم الوصول لهذه العناصر أو القيم عن طريق اسمها. مثال لتعريف struct: struct struct_name //struct_name : اسم نختاره { //هنا نكتب العناصر أو المتحولات وقيمها int id; string f_name; string l_name; float avg; } S1 ; الآن أصبح لدينا نمط جديد هو struct ويمكن أخذ غرض منه .. إما بذكر اسم الغرض بعد قوس النهاية مباشرة ( الغرض S1 ) ، أو بالشكل الاعتيادي: struct struct_name S1; مثال : للتعامل مع ال struct (الوصول إلى عناصره) و سنقوم بالتصريح عن طريقة تقبل بارمترين من نوع struct وتقوم بحساب مجموع رواتب موظفين اثنين (يمكن نسخ الكود التالي وتنفيذه لملاحظة النتائج): #include<bits/stdc++.h> using namespace std; struct employee { int id; string name; string last_name ; float salary ; float bonus ; } ; //تعريف الطريقة التي تقبل بارمترين لها من النمط ستراكت employee add_salary (employee emp1 , employee emp2) { employee result ; result.salary = emp1.salary + emp2.salary ; return result ; } int main() { employee e1,e2 ; // أخذنا غرضين من النمط السابق // مباشرة الوصول الى المتحولات واعطائها قيم e1.id = 10 ; e1.name = " ali "; e1.last_name = "haidar" ; e1.salary = 100000; e1.bonus = e1.salary * 0.2 ; // ادخال قيم متحولات الموظف الثاني من الكيبورد cout << " Enter the value of second employee's parameter is : "; cin>>e2.id>>e2.name>>e2.last_name>>e2.bonus; cout<< " the salary of first employee = "<<e1.salary<<endl; cout<<" the salary of second employee = " ; cin>>e2.salary ; employee z = add_salary(e1,e2); cout<<"the salary of two employees = "<< z.salary ; }

السبب هو أنك تستخدم tensorflow.python.keras للنموذج والطبقات و keras.optimizers لـ SGD. وهما نسختان مختلفتان.وبالتالي لم يتمكنوا من العمل معاً. يجب عليك تغيير كل شيء إلى إصدار واحد. ثم ستحل مشكلتك. أي وحد الإصدارات أو قم باستخدام كيراس لكل شيء كالتالي: from keras.layers import Dense,Embedding,LSTM from keras.models import Sequential from keras.optimizers import SGD model =Sequential() model.add(Embedding(max_features, 64)) model.add(LSTM(16)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer=SGD(lr=0.01), loss='binary_crossentropy', metrics=['acc']) history = model.fit(input_train, y_train, epochs=2, batch_size=64, validation_split=0.2) """ Loading data... 25000 train sequences 25000 test sequences Pad sequences (samples x time) input_train shape: (25000, 20) input_test shape: (25000, 20) Epoch 1/2 313/313 [==============================] - 6s 13ms/step - loss: 0.6934 - acc: 0.4900 - val_loss: 0.6934 - val_acc: 0.4964 Epoch 2/2 313/313 [==============================] - 3s 11ms/step - loss: 0.6931 - acc: 0.5031 - val_loss: 0.6931 - val_acc: 0.5036 """

يظهر هذا الخطأ لأن بياناتك غير متجانسة حيث أنك تخلط المصفوفات numpy مع القوائم. يجب أن تكون كل بيانات التدريب والاختبار مصفوفات "numpy arrays". انظر للمثال التالي: # هنا بياناتي متجانسة from keras.datasets import imdb from keras.preprocessing import sequence max_features = 10000 maxlen = 20 # تحميل البيانات # هنا تم تحميل البيانات على شكل قوائم 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)') #to_numpy إذا لم تكن بياناتك مصفوفات قم بتحويلها إلى مصفوفات نمباي باستخدام التابع # معالجة البيانات # هنا ستتحول البيانات تلقائياً إلى مصفوفات نمباي لأن تابع الحشو يردها على شكل مصفوفة input_train = sequence.pad_sequences(input_train, maxlen=maxlen) # حشو input_test = sequence.pad_sequences(input_test, maxlen=maxlen) # حشو print('input_train shape:', input_train.shape) print('input_test shape:', input_test.shape) # بناء النموذج from keras.layers import Dense,Embedding,LSTM import keras model = keras.Sequential() model.add(Embedding(max_features, 64)) model.add(LSTM(64)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc']) # أما بياناتك فهي خليط من المصفوفات والقوائم وهذا ينتج خطأ

هي طبقة تنتمي إلى فئة الطبقات المتكررة RNN (Recurrent Neural Networks) إن ال LSTM التي أطلقها Hochreiter في ورقته البحثية عام 97 ماهي إلا تطوير لشبكة ال RNN التقليدية (في كيراس وتنسرفلو SimpleRNN) التي كنت قد تحدثت عنها في سؤال سابق (تجد رابطه في الأسفل). الاختلاف كان في النقاط الأساسية التالية: 1.قدرة النظام على تخزين المعلومات لمدة أطول وبالتالي معالجة أكبر مشكلة والعيب الأساسي لل SimpleRNN وهو تضائل الاشتقاقات أي عدم قدرتها على تذكر معلومات التسلسل مع التقدم بالخطوات الزمنية أي بشكل مبسط أكثر "مثلاً عدم قدرتها على تذكر الكلمات السابقة أي مثلاً في نص طوله 50 كلمة عندما تصل للكلمة رقم 40 ستنسى ماهي الكلمة رقم 10 أي لن تتذكرها جيداً وبالتالي هذا يؤثر على فهمها للسياق وبالتالي نتائج أضعف ولاسيما في المجالات التي تركز على فهم السياق مثل الترجمة ". 2.قدرة النظام على مقاومة الضجيج (ليست ذات الصلة بالتنبؤ بإخراج صحيح). في كيراس وتنسر فلو هي عبارة عن كلاس له الشكل التالي: tf.keras.layers.LSTM( units, activation="tanh", recurrent_activation="sigmoid", 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 = 20 # تحميل البيانات print('Loading data...') (input_train, y_train), (input_test, y_test) = imdb.load_data(num_words=max_features) print(len(input_train), 'train sequences') print(len(input_test), 'test sequences') print('Pad sequences (samples x time)') # معالجة البيانات input_train = sequence.pad_sequences(input_train, maxlen=maxlen) # حشو input_test = sequence.pad_sequences(input_test, maxlen=maxlen) # حشو print('input_train shape:', input_train.shape) print('input_test shape:', input_test.shape) # بناء النموذج from keras.layers import Dense,Embedding,LSTM import keras model = keras.Sequential() model.add(Embedding(max_features, 64)) model.add(LSTM(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) """ Loading data... 25000 train sequences 25000 test sequences Pad sequences (samples x time) input_train shape: (25000, 20) input_test shape: (25000, 20) Epoch 1/10 313/313 [==============================] - 17s 36ms/step - loss: 0.6070 - acc: 0.6435 - val_loss: 0.4929 - val_acc: 0.7478 Epoch 2/10 313/313 [==============================] - 9s 30ms/step - loss: 0.3900 - acc: 0.8248 - val_loss: 0.5014 - val_acc: 0.7502 """ للإطلاع على SimpleRNN رغم أنني أجبتك عليها سابقاً:

يقوم بجعل قيم البيانات تنتمي إلى المجال من 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.

اعتقد أنه يمكنك استخدام os.path.realpath كالتالي : import os dir_path = os.path.dirname(os.path.realpath(__file__))

أولاً يجب أن تعلم أن أي كائن يمكننا المرور عليه بحلقة" looped over" هو كائن قابل للتكرار "iterable". على سبيل المثال ، كائن القائمة قابل للتكرار وكذلك كائن str. وللتأكد فيما إذا كان كائن ما قابل للتكرار في بايثون أم لا فهناك عدة طرق: أولها التابع __iter__ : s = 'Ali' if hasattr(s, '__iter__'): print(f'{s} is iterable') else: print(f'{s} is not iterable') # الخرج # Ali is iterable أو يمكنك تجربة __contains__ حيث تعتمد فكرتها على اختبار فيما إذا كان ال object يقبل المعامل in أو لا: hasattr(obj, '__contains__') # hasattr("adccads", '__contains__') True أو بنفس الفكرة مع التابع len: hasattr([8,2], "__len__") # True الطريقة الثانية هي بجعل مولد يحاول المرور على الكائن فإذا أخفق لن يكون قابل للتكرار : s="Ali" def iterable(a): try: (x for x in a) return True except TypeError: return False iterable(s) # True الطريقة الثالثة تعتمد على اختبار فيما إذا كان الكائن يمثل instance من الصف Iterable : from collections.abc import Iterable s = 'Ali' if isinstance(s, Iterable): print(f"{s} is iterable") else: print(f"{s} is not iterable") # Ali is iterable هناك طريقة أخرى خطرت لي وهي أن كل الكائنات القابلة للتكرار تمتلك التابع __getitem__ في ال dict الخاص بها: def is_attr(arg): return '__getitem__' in dir(arg) is_attr([5,8]) #True يمكنك أيضاً استخدام التابع iter لأنه في Python، المكرر هو أي كائن يدعم بروتوكول المكرر. جزء من هذا البروتوكول هو أن الكائن يجب أن يحتوي على طريقة __iter __ تقوم بإرجاع كائن المكرر لذالك أيضاً هنا نستطيع التحايل في استخدامها للاختبار : name = "ِAli" try: iter(name) print("{} is iterable".format(name)) except TypeError: print("{} is not iterable".format(name))

هو مصنف يقوم بالتنبؤات باستخدام قواعد بسيطة. هذا المصنف يتم استخدامه كخط أساس 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