Ali Haidar Ahmad

من أجل تسجيل غرض من الصف البعيد في مسجل RMI باسم ما، نستطيع استخدام  الطريقة bind والطريقة rebind ولكن الفرق الأساسي بينهما هو أن rebind تستخدم حتى لوكان الاسم موجود مسبقاً (تكتب فوقه)، لكن عندها سيتم إتلاف عملية ال binding السابقة واستبدالها بالجديدة (أي تحذف القديمة وتضع الجديدة) بينما bind لايمكنها القيام بذلك حيث تقوم برمي استثناء في حال كان الاسم موجود بالفعل AlreadyBoundException ومن حيث الاستخدام فالطريقتين السابقتين متشابهتين، كلاهما تأخذان متحولين ( اسم ما للغرض ، الغرض البعيد). نقوم أولا بإنشاء مسجل RMI من خلال استدعاء الطريقة الستاتيكية creatRegistry الموجودة ضمن الصف LocateRegistry، ونحجز له بورت هنا مثلاً (1999):
Registry r = LocateRegistry.createRegistry(1999); ثم نأخذ غرض وليكن rb من الصف البعيد ( RemoteObject مثلاً) ونقوم بتسجيله في مسجل RMI بالاسم ("object1") عبر استدعاء إحدى الطريقتين:
r.bind("object1", rb); r.rebind("object1", rb);  

ReLU (Rectified Linear Unit) هو تابع تنشيط خطي على القسم الموجب وخطي على القسم السالب، لكن تركيبهما هو مابعطيه الصفة اللاخطية، له الشكل الرياضي البسيط التالي:
max(0,x) بحيث من أجل دخل x>0 سيكون خرجه هو x نفسها  (أي لاتغيير أي كأننا لم نستخدم تابع تنشيط أي None ) ومن أجل دخل أصغر من الصفر يكون الخرج 0، هذا يعني أنه يسلك سلوك None من أجل الجزء الموجب وكما نعلم فإن أسعار المنازل هي دوماً موجبة وبالتالي استخدام relu سيكون مكافئاً ل None ولكن أفضل لأنه في حالة توقع النموذج قيمة سالبة للنموذج سوف يقصرها على 0 أي إذا توقع -5 سوف يجعلها 0 بسبب تابع ال relu ولهذا السبب كان استخدامه يعطي نتيجة أفضل، لكن هذا لايعني أن استخدامه صحيح وخصوصاً إذا كانت القيم السالبة ضمن مجال التوقع، وأيضاً استخدامه قد يضلل نموذجك قليلاً في الوصول للقيم الصغرى الشاملة لذا أنا أفضل عدم استخدامه. الشكل البياني للتابع:

كما نلاحظ فإن قيم المشتق تساوي الصفر أيضاً من أجل القيم السالبة (ليس أمراً جيداً لأنه يسبب بطء لكنه مهمل هنا)، بينما من أجل القيم الموجبة يكون حالة مثالية للتدريب حيث أن قيمة المشتق تكون كبيرة وثابتة (القيمة تساوي 1 كما نلاحظ في الرسم). وهذا يجعل عملية التدريب أسرع (التقارب من القيم الصغرى الشاملة). أحد سلبيات هذا التابع أنه يقوم بتحويل جميع القيم السالبة إلى صفر، اي أنه في حالة القيم السالبة سينظر إليها التابع بشكل واحد وهو الصفر, مما قد يتسبب بخسارة معلومات هامة أثناء تدريب الشبكة.
في كيراس أو تنسرفلو له الشكل التالي:
tf.keras.activations.relu(x, alpha=0.0, max_value=None, threshold=0) بحيث أن x هي tensor أو متغير ما. أما alpha فيتحكم في ميل القيم الأقل من العتبة. أما max_value فهي التي تحدد عتبة التشبع (أكبر قيمة سترجعها الدالة). أما الوسيط الأخير فهو العتبة أي إعطاء القيمة الحدية لوظيفة التنشيط التي تحتها القيم التي سيتم تثبيطها أو ضبطها على الصفر. وافتراضياً تكون 0. ولاستخدامه في تدريب نموذجك يمكنك استخدامه مع جميع الطبقات في الشبكة عدا طبقة الخرج. وشخصياً أنصحك باستخدامه في جميع طبقات شبكتك  (عدا طبقة الخرج طبعاً) لأنه سيجعل نموذجك يتقارب من القيم الصغرى بشكل أسرع كما ذكرت. إليك المثال التالي الذي سأقوم فيه باستخدام هذا التابع في تدريب نموذجي، أول مثال لمهمة توقع:
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() # يمكنك تمريره إلى طبقتك بالشكل التالي # أو tf.keras.activations.relu() 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']) history = model.fit(train_data, train_targets,epochs=7, batch_size=1, verbose=1) ------------------------------------------------- Epoch 1/7 404/404 [==============================] - 1s 967us/step - loss: 338.1444 - mae: 15.1877 Epoch 2/7 404/404 [==============================] - 0s 1ms/step - loss: 21.6941 - mae: 3.1332 Epoch 3/7 404/404 [==============================] - 0s 1ms/step - loss: 17.6999 - mae: 2.8479 Epoch 4/7 404/404 [==============================] - 0s 947us/step - loss: 13.1258 - mae: 2.4018 Epoch 5/7 404/404 [==============================] - 0s 970us/step - loss: 15.7603 - mae: 2.6360 Epoch 6/7 404/404 [==============================] - 0s 1ms/step - loss: 12.1877 - mae: 2.3640 Epoch 7/7 404/404 [==============================] - 0s 965us/step - loss: 9.7259 - mae: 2.2152 و لاستخدامه مع مهام التصنيف، يكون أيضاً بنفس الطريقة.

يعتبر هذا التابع تابع لوجيستي "logistic function" وهو تابع غير خطي، الشكل الرياضي له:
g=sigmoid(x) = 1 / (1 + exp(-x)). والشكل البياني لهذا التابع هو كالتالي:

نلاحظ من الخط البياني للتابع أن قيمه تتراوح بين 0 و 1، حيث: عندما z=-∞ تكون قيمة التابع g=0 وعندما z=0 يكون g=0.5 وعندما z=+∞ يكون g=1.
ومن الرسم البياني نلاحظ أنه يمكن استخدامه في تدريب النماذج (أقصد أنه يعطي قيماً مختلفة عن الصفر أي هناك تغيرات في ميل المماس)، وكما نلاحظ من الرسم (المنحني الأزرق) فإن المشتق تكون قيمه فعالة للتدريب عندما تكون قيم z قريبة من الصفر ولكن من أجل قيم كبيرة جداً أو صغيرة جداً فلن تكون فعالة في التدريب لأن المماس يكون شبه مستقيم وبالتالي قيمة المشتقة تكون صغيرة جداً، مما يؤدي الى بطء شديد في عملية التدريب وبالتالي مكلف من الناحية الحسابية. إن الاستخدام الشائع والأهم والأفضل لهذا التابع هو استخدامه كمصنف في آخر طبقة من نموذج عندما تكون المهمة مهمة تصنيف ثنائي حيث أن خرجه يكون قيمة احتمالية بين 0 و 1 وبالتالي خيار ممتاز لمهام التصنيف الثنائي. وفي كيراس وتنسرفلو له الشكل التالي:
tf.keras.activations.sigmoid(x) مثال:
a = tf.constant([-20, -1.0, 0.0, 1.0, 20], dtype = tf.float32) b = tf.keras.activations.sigmoid(a) b.numpy() # الخرج array([2.0611537e-09, 2.6894143e-01, 5.0000000e-01, 7.3105860e-01, 1.0000000e+00], dtype=float32) لاستخدامه في نماذجك، يمكنك استخدامه في أي طبقة، لكن كما ذكرت يفضل استخدامه فقط في آخر طبقة عندما تكون المهمة مهمة تصنيف ثنائي كما في المثال التالي:
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)  

يجب أن يتم تمرير الموتر "Tensor" إلى الطبقة عند استدعائها، وليس كوسيطة.  أو ببمعنى آخر الأٌقواس () مفقودة لذلك يجب أن تعدله كالتالي:
# إنشاء طبقة layer = Flatten() #tensor استدعاءها على z = layer(z) # أو بشكل أبسط z = Flatten()(z) انظر لهذا المثال أيضاً سينتج نفس الخطأ والحل بنفس الطريقة:
def create(input_shape = (100, 100, 3)): input_img = Input(shape=input_shape) model = efnB0_model (input_img) model = GlobalMaxPooling2D(model) # سيعطي نفس الخطأ model = Dropout(0.2)(model) backbone = model ... ... return model  

المشكلة في التعليمات البرمجية الخاصة بك هي أنك تريد تطبيق العملية على كل صف. الطريقة التي كتبتها بها تأخذ عمودي "bar" و "foo" بالكامل ، وتحولها إلى سلاسل وتعطيك سلسلة واحدة . لذا يمكنك حل المشكلة بالشكل التالي:
from pandas import * import numpy df = DataFrame({'foo':['a','b','c'], 'bar':[1, 2, 3]}) df.apply(lambda x:'%s is %s' % (x['bar'],x['foo']),axis=1) ومن خلال نمباي يمكنك القيام بذلك باستخدام الكلاس  numpy.chararray حيث نقوم بتحويل الأعمدة إلى تسلسل على هيئة chararrays، ثم نقوم بدمجهم معاً كالتالي:
from pandas import * import numpy d = DataFrame({'foo':['a','b','c'], 'bar':[1, 2, 3]}) def join(d): a = numpy.char.array(d['bar'].values) b = numpy.char.array(d['foo'].values) bar=(a + b' is ' + b).astype(str) return DataFrame({'bar':bar}) join(d) """ bar 0 1 is a 1 2 is b 2 3 is c """

هذا خطأ شائع يقع فيه المبتدئين، وهو استخدام توابع التنشيط في آخر طبقة من طبقات نماذج التوقع، يجب أن تتذكر دوماً أن مسائل التوقع Regression تكون فيها قيم الخرج قيم مستمرة أي قيم غير محدودة بمجال معين أي ليست كما في ال classifications حيث يكون فيها الخرج قيم متقطعة أي قيم معينة. لذلك لايجب استخدام أحد توابع التنشيط معها ولاسيما توابع التنشيط اللوجستية مثل التابع السيني sigmoid أو حتى tanh. لأن هذين التابعين خرجهما يكون بين ال 0 وال 1 (بالنسبة للسيني) و من 1 لل -1 (بالنسبة لل tanh). وبالتالي إذا استخدمت أحدهما في آخر طبقة سيكون خرج نموذجك قيماً محصورة بمجال محدد وهذا خاطئ لأنه في أي مهمة توقع ولتكن مهمة توقع أسعار المنازل مثلاً، يجب أن يكون الخرج قيماً تنتمي إلى مجال غير محدود (قيم مستمرة) أما إذا استخدمت التابع السيني مثلاً سيكون خرج النموذج من أجل أي عينة قيمة محصورة بالمجال من 0 ل 1 والقيمة الحقيقية قد تكون 100 أو 50 أو 77 أو أو.. وبالتالي سيكون مقدار الخطأ في التوقع كبير جداً. لذا يجب ضبط تابع التنشيط في آخر طبقة على None دوماً.
حسناً أنت تتساءل لماذا تابع ال relu يعطيك نتائج جيدة، وهذا صحيح فبالفعل قد يعطيك نتائج جيدة وفي بعض الأحيان قد يعطيك نتائج أفضل من عدم استخدام تابع تنشيط أي None كالمثال التالي، حيث سنستخدم relu  والخطأ المطلق mae=2.2152:
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='relu')) 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 967us/step - loss: 338.1444 - mae: 15.1877 Epoch 2/7 404/404 [==============================] - 0s 1ms/step - loss: 21.6941 - mae: 3.1332 Epoch 3/7 404/404 [==============================] - 0s 1ms/step - loss: 17.6999 - mae: 2.8479 Epoch 4/7 404/404 [==============================] - 0s 947us/step - loss: 13.1258 - mae: 2.4018 Epoch 5/7 404/404 [==============================] - 0s 970us/step - loss: 15.7603 - mae: 2.6360 Epoch 6/7 404/404 [==============================] - 0s 1ms/step - loss: 12.1877 - mae: 2.3640 Epoch 7/7 404/404 [==============================] - 0s 965us/step - loss: 9.7259 - mae: 2.2152 أما بدونه mae: 2.3221:
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: 280.0789 - mae: 13.5154 Epoch 2/7 404/404 [==============================] - 0s 1ms/step - loss: 19.4468 - mae: 3.0621 Epoch 3/7 404/404 [==============================] - 0s 1ms/step - loss: 17.4921 - mae: 2.9243 Epoch 4/7 404/404 [==============================] - 0s 1ms/step - loss: 14.3356 - mae: 2.6068 Epoch 5/7 404/404 [==============================] - 0s 1ms/step - loss: 12.1125 - mae: 2.4581 Epoch 6/7 404/404 [==============================] - 0s 952us/step - loss: 16.5646 - mae: 2.5852 Epoch 7/7 404/404 [==============================] - 0s 1ms/step - loss: 12.4237 - mae: 2.3221 حسناً كما تلاحظ فإن النتيجة أفضل مع relu، والسبب في أن التابع relu هو تابع خطي خرجه من الشكل:
max(x, 0) بحيث من أجل دخل x>0 سيكون خرجه هو x نفسها  (أي لاتغيير أي كأننا لم نستخدم تابع تنشيط أي None ) ومن أجل دخل أصغر من الصفر يكون الخرج 0، هذا يعني أنه يسلك سلوك None من أجل الجزء الموجب وكما نعلم فإن أسعار المنازل هي دوماً موجبة وبالتالي استخدام relu سيكون مكافئاً ل None ولكن أفضل لأنه في حالة توقع النموذج قيمة سالبة للنموذج سوف يقصرها على 0 أي إذا توقع -5 سوف يجعلها 0 بسبب تابع ال relu ولهذا السبب كان استخدامه يعطي نتيجة أفضل، لكن هذا لايعني أن استخدامه صحيح وخصوصاً إذا كانت القيم السالبة ضمن مجال التوقع، وأيضاً استخدامه قد يضلل نموذجك قليلاً في الوصول للقيم الصغرى الشاملة لذا أنا أفضل عدم استخدامه.

أنت تحاول الوصول إلى ال history من دون أن تقوم بتخزينها، لذا قم بتخزين ال history حيث أن التابع model.fit يعيد History object وهذا الكائن لديه العضو history من النمط dict لذا:
########################## في جزء التدريب###################### # بدلاً من model1.fit(data, label, validation_split=0.2, epochs=13) model2.fit(data, label, validation_split=0.2, epochs=13) model3.fit(data, label, validation_split=0.2, epochs=13) # اكتب history1=model1.fit(data, label, validation_split=0.2, epochs=13) history2=model2.fit(data, label, validation_split=0.2, epochs=13) history3=model3.fit(data, label, validation_split=0.2, epochs=13) ######################### في جزء الرسم ######################### plt.plot(history1.history['val_loss'], 'r', history2.history['val_loss'], 'b', history3.history['val_loss'], 'g')  

هذه الطبقة كما يشير اسمها هي طبقة تسطيح (أو تسوية أو إعادة تشكيل) المدخلات. نستخدمها عادة مع النماذج عندما نستخدم طبقات RNN و CNN. ولفهمها جيداً سأشرحها مع المثالين التاليين، الأول مع مهمة تحليل مشاعر imdb أي مع مهمة NLP وسنستخدم طبقات RNN وسنتحتاج إلى الطبقة flatten:
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) 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) حسناً  هنا قمنا بتسطيح الخرج الناتج من طبقة التضمين Embedding أي قمنا بتسطيح (تحويل) ال 3D tensor التي أنتجتها طبقة التضمين إلى 2Dtensor بالشكل التالي (samples,maxlen * 8)( أي عدد العينات أو الباتشز لايتأثر كما أشرنا في التعريف وإنما يتم إعادة تشكيل الفيتشرز). لقد قمنا  هضه العملية لأن الطبقة التي تلي طبقة التضمين هي طبقة من نوع Dense وهي طبقة تستقبل 2D tensor ولاتستقبل 3D وبالتالي وجب علينا تسطيح مخرجات طبقة التضمين.
مثال آخر:
def lstm_model_flatten(): embedding_dim = 128 model = Sequential() model.add(layers.Embedding(vocab_size, embedding_dim, input_length=maxlen)) model.add(layers.LSTM(128, return_sequences = True, dropout=0.2)) # Flatten layer هنا أيضاً سنحتاج model.add(layers.Flatten()) model.add(layers.Dense(1,activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) model.summary() return model هنا استخدمنا طبقة التسطيح لأن مخرجات طبقة lstm هي 3D كما نعلم وذلك لأننا ضبطنا return_sequences على true، والطبقة التالية هي dense وبالتالي لابد من تسطيح المخرجات بنفس الطريقة.
الآن حالة آخرى مع الطبقات التلاففية حيث أنني بنيت نموذج لتصنيف الأرقام المكتوبة بخط اليد:
from keras import layers from keras import models from keras.datasets import mnist from keras.utils import to_categorical (train_images, train_labels), (test_images, test_labels) = mnist.load_data() train_images = train_images.reshape((60000, 28, 28, 1)) train_images = train_images.astype('float32') / 255 test_images = test_images.reshape((10000, 28, 28, 1)) test_images = test_images.astype('float32') / 255 train_labels = to_categorical(train_labels) test_labels = to_categorical(test_labels) # بناء النموذج model = models.Sequential() model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) # هنا سنتحتاجها model.add(layers.Flatten()) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(10, activation='softmax')) # تدريب النموذج model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(train_images, train_labels, epochs=5, batch_size=64) حسناً، إن خرج كل طبقة Conv2D و MaxPooling2D هو 3D Tensor من الشكل (height, width, channels). إن آخر خطوة من بناء الشبكة التلاففية هو إضافة طبقة أو مجموعة طبقات dense وبالتالي تتم تغذية هذه الطبقة بآخر tensor أنتجتها طبقاتنا التلاففية (هنا (64, 3, 3))  وكما ذكرنا فإن dense لاتستقبل 3D وبالتالي يجب تسطيحها، ,وبالتالي هنا سيكون ناتج تسطيح الخرج هو شعاع 1D أبعاده 64*3*3 وهذا ماسوف تتغذى  به طبقات ال dense.

إن الطبقات التي نقوم باستخدامها في keras و tensorflow هي طبقات تتعامل مع بنية بيانات نسميها tensor (بنية خاصة أكثر كفاءة من بنى المصفوفات العادية)، حيث أن هذه الطبقات صممت بحيث يمكنها أن تستقبل بيانات من نوع numpy.array ثم تحولها تلقائياً إلى tensor. لكن هذه الطبقات لاتتعامل مع القوائم وأنت تمرر لها قائمة وهذا خطأ شائع، لذا يجب أن تحول بياناتك إلى مصفوفة نمباي أولاً وستحل مشكلتك:
import numpy data = numpy.array(data) label = numpy.array(label)  

لقد قمت بتعريف نموذجك مع مخرجين [output1, output2]، لذلك من المتوقع أن يتم عمل ال fitting مع مصفوفتين مختلفتين من ال label. واحدة بحجم (, 119) والأخرى (,2) وهذا مايتوافق مع طبقتي الإخراج Dense لديك. الحل:
g = ImageDataGenerator() def generate_data_generator(g, X, Y1, Y2): genX1 = generator.flow(X, Y1, seed=7) genX2 = generator.flow(X, Y2, seed=7) while True: X1i = genX1.next() X2i = genX2 .next() yield X1i[0], [X1i[1], X2i[1]] model.fit_generator(generate_data_generator(generator, x_train, y_train, y_train_gender), steps_per_epoch=len(x_train) / 16, epochs=5)  

قم بتبديل:
from keras.applications.imagenet_utils import _obtain_input_shape إلى:
from keras_applications.imagenet_utils import _obtain_input_shape فهي غير موجودة في keras.applications.imagenet_utils، يمكنك أن تجدها في keras_applications.imagenet_utils

فقط استدعي  ()tensor.numpy على ال Tensor object
# tensorflow_version 2.x # مثال1 import tensorflow as tf t = tf.constant([[1, 2], [4, 8]]) a = t.numpy() print(a) print(type(a)) """ [[1 2] [4 8]] <class 'numpy.ndarray'> """ # مثال 2 import tensorflow as tf a = tf.constant([[1, 2], [3, 4]]) b = tf.add(a, 1) a.numpy() # array([[1, 2], # [3, 4]], dtype=int32) b.numpy() # array([[2, 3], # [4, 5]], dtype=int32) tf.multiply(a, b).numpy() # array([[ 2, 6], # [12, 20]], dtype=int32) إذا كانت النسخة هي TensorFlow version 1.x استخدم:
tensor.eval(session=tf.compat.v1.Session()) مثال:
# tensorflow_version 1.x import tensorflow as tf t = tf.constant([[1, 2], [4, 8]]) a = t.eval(session=tf.compat.v1.Session()) print(a) print(type(a))
أيضاً يجب أن تعلم أنه بمجرد استخدامك لأي عملية من عمليات نمباي على ال tensor سوف تتحول تلقائياً إلى numpy array، في الكود التالي مثلاً ، نقوم أولاً بإنشاء Tensor وتخزينه في متغير t عن طريق إنشاء ثابت Tensor ثم استخدام تابع  الضرب في TensorFlow والناتج هو نوع بيانات Tensor أيضاً . بعد ذلك ، نقوم بإجراء عملية np.add () على Tensor التي تم الحصول عليها من خلال العملية السابقة. وبالتالي ، تكون النتيجة عبارة عن NumPy ndarray حيث تم إجراء التحويل تلقائيًا بواسطة NumPy.
import numpy as np import tensorflow as tf #tensor إنشاء كائن t = tf.constant([[1, 2], [4, 8]]) t = tf.multiply(t, 2) print(t) # تطبيق عملية من نمباي a = np.add(t, 1) print(a) # هذا كل شيء

قبل كل شيء المتوسط المتحرك في علم الإحصاء، المتوسط المتحرك (MA) هو عملية حسابية تُستخدم لتحليل نقاط البيانات (العينات) عن طريق إنشاء سلسلة من المتوسطات لمجموعات فرعية مختلفة من مجموعة البيانات الكاملة. ويستخدم في عالم الأموال، حيث أن المتوسط المتحرك (MA) هو مؤشر سهم يستخدم بشكل شائع في التحليل التقني. والسبب في حساب المتوسط المتحرك للسهم هو المساعدة في تسهيل بيانات السعر عن طريق إنشاء متوسط سعر محدث باستمرار. ومن خلال حساب المتوسط المتحرك ، يتم تخفيف آثار التقلبات العشوائية قصيرة الأجل على سعر السهم خلال إطار زمني محدد. لن أخوض في تفاصيله الممتعة أكثر. له نوعان، Simple Moving Average:
أبسط شكل من أشكال المتوسط المتحرك ، والمعروف باسم المتوسط المتحرك البسيط (SMA) ، يتم حسابه بأخذ المتوسط الحسابي لمجموعة معينة من القيم. بمعنى آخر ، يتم جمع مجموعة من الأرقام - أو الأسعار في المجال المالي - معًا ثم تقسيمها على عدد الأسعار في المجموعة. (وهو النوع الأكثر استخداماً)
SMA=(A1+A2+..+AN)/n A:nهي المتوسط في الفترة N: عدد الفترات الزمنية  Exponential Moving Average (EMA):
يعطي وزناً أكبر للأسعار الحديثة في محاولة لجعله أكثر استجابة للمعلومات الجديدة. لحساب المتوسط المتحرك الأسي:
EMAt=[Vt×S/(1+d)]+EMAy×[1−S/(1+d)] EMAt: لليوم Vt: هي القيمة لليوم EMAy: للأمس S: التنعيم d:عدد الأيام الآن كيف نطبقه في بايثون:
1.الطريقة الأولى: قم بإنشاء قائمة فارغة تحتوي على المتوسطات المتحركة. قم بالمرور على القائمة الأصلية باستخدام حلقة while. في كل تكرار ، استخدم فهرسة القائمة للحصول على النافذة الحالية. استخدم sum(iterable) / w_s ثم أضف هذه النتيجة إلى قائمة المتوسطات المتحركة:
li = [6, 7, 10, 12] # حجم النافذة w_s = 3 i = 0 moving_averages = [] j=len(li) - w_s + 1 while i < j: this_window = li[i : i + w_s] window_avg = sum(this_window) / w_s moving_averages.append(window_avg) i += 1 print(moving_averages) 2. من أجل القوائم الكبيرة تقدم باندا طريقة فعالة هي pandas.Series(data) لتحويل القائمة إلى pandas.Series object. ثم استدعي pandas.Series.rolling (window_size) للحصول على كائن يحتوي كل نافذة، ثم استدعي pandas.Series.mean لإيجاد المتوسط لكل نافذة :
li = [6, 7, 10, 12] w_s = 3 pd = pd.Series(li) windows = pd.rolling(w_s) moving_averages = windows.mean() # pandas.Series.tolist() لتحويلها لقائمة moving_averages_list = moving_averages.tolist() # حذف القيم Nan w = moving_averages_list[w_s - 1:] print(w) 3.باستخدام نمباي:
4. والطريقة الأكثر سرعة هي استخدام uniform_filter1d من scipy فهي أسرع بنحو 50 مرة من np.convolve و 2-5 مرات من cumsum :
from scipy.ndimage.filters import uniform_filter1d import numpy N = 1000 x = numpy.random.random(100000) y = uniform_filter1d(x, size=N) لاحظ:
%timeit y1 = np.convolve(x, np.ones((N,))/N, mode='same') 100 loops, best of 3: 9.28 ms per loop %timeit y2 = uniform_filter1d(x, size=N) 10000 loops, best of 3: 191 µs per loop إليك التحقيقات الثلاثة التي ذكرتها:
import numpy as np import scipy.ndimage.filters as ndif from __future__ import division #cumsum استخدام def running_mean_cumsum(x, N): cumsum = np.cumsum(np.insert(x, 0, 0)) return (cumsum[N:] - cumsum[:-N]) / float(N) #convolve استخدام def running_mean_convolve(x, N): return np.convolve(x, np.ones(N) / float(N), 'valid') #uniform_filter1d وأخيراً def running_mean_uniform_filter1d(x, N): return ndif.uniform_filter1d(x, N, mode='constant', origin=-(N//2))[:-(N-1)]  

إن الخطوة الأخيرة التي تسبق تغذية شبكتك العصبية بالبيانات هي توحيد طول السلاسل، حتى لو كنت تستخدم أي نوع من الشبكات يجب القيام بهذه الخطوة (لكن تختلف طريقة التوحيد تبعاُ لنوع ترميزك طبعاً وهنا نستخدم 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  

نعم هناك فرق وكل نوع منهما يستخدم مع أنواع محددة. حيث إن عملية الفلترة تهدف لإزالة الضجيج من صورة ما، وهناك نوعين أساسيين للضجيج: ضجيج خطي وضجيج غير خطي .ولكل نوع منهما طريقة لإزالته فالخطي تتم إزالته بمرشحات خطية مثل ال 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  

هي نسخة محسنة من الشبكة العصبية 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 كما أشرنا.

أولاً أحب أن ألفت الانتباه إلى أن الأمر غير مرتبط ب 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  

هي تطوير لفكرة الشبكات العصبية المتكررة 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) إن الطبقات ثنائية الاتجاه تعطيك أداء أفضل من ناحية الدقة لكنها تستهلك زمن كبير جداً مقارنة بالطبقات أحادية الاتجاه.

السبب هو أنك تستخدم  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 """  

هي طبقة تنتمي إلى فئة الطبقات المتكررة 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 رغم أنني أجبتك عليها سابقاً: