Ali Haidar Ahmad

بشكل عام هناك 4 مقاييس أساسية لقياس كفاءة المودل عندما تكون المهمة من نوع Regrission (توقع):
أول ورابع معيار هم الأكثر استخداماً.
أولاً: Mean Absolute Error
وهي متوسط الفروق بالقيمة المطلقة بين القيم الحقيقية والقيم المتوقعة في مجموعة البيانات، والصورة المرفقة في الأسفل توضح الشكل العام للمعادلة الرياضية المعبرة عنها.
ثانياً: Mean Squared Error
وهي متوسط مربع الفروق بين القيم الحقيقية والمتوقعة، في الأسفل تم توضيح الشكل الرياضي للمعادلة.
ثالثاُ: Root Mean Squared Error
وهو جذر ال Mean Squared Error، في الأسفل تم توضيح الشكل الرياضي للمعادلة.
رابعاً: R Squared
معايير القياس المذكورة أعلاه سيكون لها قيم مختلفة لنماذج مختلفة، أي ليس لها مجال ثابت لكي نخمن على أساسه هل النموذج جيد أم لا، فمثلاً في مشكلة توقع أسعار المنازل قد يكون مجال القيم لهما بين 100 و 400 دولار وفي مسألة توقع درجة الحرارة قد يكون المجال بين ال 1 و 4 (أي القيم الناتجة ليست سهلة القراءة)، أما في هذا المقياس فسوف يكون مجال القيم محصور بين ال 0 وال 1، بحيث 1 تعني أن النموذج خالي من الأخطاء و 0 تعني أن النموذج فاشل تماماً. في الصورة المرفقة في الأسفل تم توضيح الشكل الرياضي للمعادلة.
مثال:
# انتبه أن التابع mean_squared_error يقبل وسيط بولياني يسمى squared في حال ضبطه على True سيتم حساب MSE أما في حال ضبطه على False سوف يحسي MSE ثم يأخذ الجذر أي يصبح RMSE.
####################################### Example ############################################### # استيراد الدوال from sklearn.metrics import mean_absolute_error from sklearn.metrics import mean_squared_error from sklearn.metrics import r2_score y_true = [80.3, 100, -7.7] # نفرض أن القيم الحقيقية كانت y_pred = [85, 99, -0.5] # والقيم المتوقعة ####################################### MAE ################################################## print("MAE is: "+str(mean_absolute_error(y_true, y_pred))) # output: MAE is: 4.300000000000001 ####################################### MSE ################################################## print("MSE is:"+str(mean_squared_error(y_true, y_pred,squared=True))) # MSE is:24.976666666666677 ####################################### RMSE ################################################## print("RMSE is:"+str(mean_squared_error(y_true, y_pred,squared=False))) # RMSE is:4.997666121968001 ####################################### R Squaerd ################################################## print("R Squaerd is:"+str(r2_score(y_true, y_pred)))#R Squaerd is:0.9886074871600465 مثال واقعي على مهمة توقع أسعار المنازل في مدينة بوسطن، حيث أن البيانات تمثل مواصفات المنازل وأسعارها في تلك المدينة :
 
####################################### مثال عملي ################################################## from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split from sklearn.metrics import mean_absolute_error from sklearn.metrics import mean_squared_error from sklearn.metrics import r2_score from sklearn.linear_model import LinearRegression # تحميل الداتاسيت BostonData = load_boston() x = BostonData.data y = BostonData.target # تقسيم الداتا إلى عينة تدريب وعينة اختبار X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=44, shuffle =True) #تعريف LinearRegressionModel LR = LinearRegression() LR.fit(X_train, y_train) # حساب القيم المتوقعة y_pred = LR.predict(X_test) # Mean Absolute Error MAE = mean_absolute_error(y_test, y_pred) print('Mean Absolute Error Value is : ', MAE) #Mean Absolute Error Value is : 3.4318693222761523 # Mean Squared Error MSE = mean_squared_error(y_test, y_pred,squared=True) print('Mean Squared Error Value is : ', MSE) #Mean Squared Error Value is : 21.439149523649792 # Root Mean Squared Error RMSE = mean_squared_error(y_test, y_pred,squared=False) print('Root Mean Squared Error Value is : ', RMSE) #Root Mean Squared Error Value is : 4.6302429227471205 # R Squaerd print("R Squaerd is: "+str(r2_score(y_test, y_pred))) # R Squaerd is: 0.7532417995961468 فرانسوا كوليت ينصح باعتماد MAE.
 

اعتقد أنك تقصد كيفية إنشاء قائمة من الكائنات.
 
# تعريف صف class hsoub: def __init__(self, name, ID): self.name = name self.ID = ID list = [] # إنشاء قائمة # إضافة كائنات إلى الصف list.append( hsoub('Ali', 9) ) list.append( hsoub('Ahmad', 6) ) list.append( hsoub('Mohameed', 8) ) # طباعة for object in list: print( object.name, object.ID ) هل تريد شيئاً إضافياً؟

dic1={'team1':5, 'lose1':39} dic2={'team2':3, 'lose2':40} def combine(f1, f2): dic = f1.copy() #dic ننشئ نسخة من القاموس الأول ونسميها dic.update(f2) # نضيف لهذا القاموس مفاتيح وقيم القاموس الثاني return dic combine(dic1, dic2) ''' في حال كانت إحدى المفاتيح في القاموس الأول موجودة في الثاني فسيتم استبدالها بمفاتيح الثاني ''' ويمكن أن تجرب:
dic = dict(list(dic1.items()) + list(dic2.items())) حيث items هي تابع يرد المفاتيح والقيم في أول قاموس وتضعهم على شكل list من ال tuble ثم تدمجهما مع الثانية وتحولهما في النهاية إلى قاموس
في النسخ الحديثة من بايثون يمكنك أن تفعل هذا ببساطة :
dic = {**dic1, **dic2}  

f=[ {'team':'barca', 'lose':39}, {'team':'real', 'lose':40}, {'team':'ATM', 'lose':10}] from operator import itemgetter f = sorted(f, key=itemgetter('lose'),reverse=True) # سيكون الترتيب من الأصغر للأكبر False إذا وضعت print(f)  

import pandas as pd # لنفرض لدينا البيانات التالية dic = {'c1':[17, 3, 4], 'c2':[66, 77, 66], 'c3':[66, 77, 5]} # DataFrame نحولها ل df = pd.DataFrame(dic) print(df,end='\n\n') # عرض البيانات ################################ للاستعلام ######################################## # select * from table where column_name = some_value < تكافئ > table[table.column_name == some_value] # :مثال values=df[df.c2 == 66] # c2 أي سنختار الأسطر التي تتضمن القيمة 66 في العمود print(values,end='\n\n') # عرض نتيجة الاستعلام values=df.query('c2 == 66') # طريقة أخرى print(values,end='\n\n') # :أما في حالة كان لديك عدة شروط نستخدم # table.query('column_name1 == value1 | column_name2 == value2') # :أو # table[(table.column_name1 == some_value1) | (table.column_name2 == some_value2)] values=df[(df.c3 == 77) | (df.c1 == 3)] print(values) # وكان بإمكانك تجربة الشكل الثاني أيضاً  

(object)append تضيف كائن في نهاية ال list كما هو:
li = ['adam', 'messi',44] li.append([5,5]) # الخرج : ['adam', 'messi', 44, [5, 5]] (iterable)extend تقوم بإضافة عناصر إلى ال list من iterable (أي list أخرى أو tuble أو set أو dict):
li2 = ['adam', 'messi',44] li2.extend([5,5]) # الخرج : ['adam', 'messi', 44, 5, 5] # لاحظ كيف اختلفت عملية الإضافة (index,value)insert: تستخدم لإضافة عنصر جديد في مكان محدد في الـlist الذي قام باستدعائها.
 
li3 = ['adam', 'messi',44] li3.insert(0,[5,5]) # الخرج : [[5, 5], 'adam', 'messi', 44]  

يمكن تحقيقه باستخدام المصفوفات (سافترض أن لديك معرفة نظرية بسيطة حوله):
المكدس عبارة عن نموذج خاص لتخزین البیانات واستخراجها بآلیة الداخل أولاً الخارج أخراً أو الداخل أخيراً يخرج أولاً
LIFO (LAST INPUT FIRST OUTPUT) 
نستخدم مع المكدس مؤشر واحد فقط نسميه top. عند إدخال أول قیمة فإننا نزید من قيمته فيصبح صفراً وكل ما أدخلنا قیمة جديدة فإن المؤشر یزید بمقدار واحد إلى أن یمتلئ  المكدس.
عندما یكون المكدس فارغاُ يكون top=-1 وعند القيام بعملیة إخراج لقيمة من المكدس فإننا ننقص المؤشر بمقدار واحد إلى أن تصل قیمة المؤشر إلى -1.
 
import java.io.*; class javaapplication1 { static final int CAPACITY=5; // يمكنك تعديلها static int[] Stack=new int[CAPACITY]; static int top=-1; // ویسمى ذیل المكدس وھو متغیر عام تستطیع الدوال الوصول إليهTop تعریف static boolean isEmpty(){ // اختبار المكدس فيما إذا كان فارغاً return (top < 0); } static boolean isFull(){ // اختبار المكدس فيما إذا كان ممتلئ return (top+1== CAPACITY); } /* حجم المصفوفة -1 = top نعلم أن المكدس ممتلئ عندما یكون مؤشر الذیل أي top وإلا سنزید من المؤشر بواحد وسنضع القیمة بداخل المصفوفة بداخل الموقع الذي تكون قیمته أي اقل من الصفر top=-1 نعلم أن المكدس يصبح فارغاً عندما تكون قیمة المؤشر وسنطرح قیمة المؤشر top وإلا سنخرج القیمة من داخل المصفوفة التي تحمل عنوان قیمة بواحد. */ static void push(int element){ // دالة لإدخال البیانات إلى المكدس if (isFull()) // إذا كان ممتلئ لايمكن الإضافة عليه System.out.println("Stack is full."); else // نضيف العنصر الجديد إلى المكدس فيما عدا ذلك Stack[top++] = element; } static int pop(){ // دالة أخراج البیانات من المكدس if (isEmpty()){ System.out.println("Stack is empty."); System.exit( 0 ); } return Stack[top--]; } // اختبار التوابع public static void main(String args[])throws IOException{ String num; BufferedReader br = new BufferedReader(new InputStreamReader (System.in)); System.out.println( "Enter first integer" ); while(!isFull()){ num=br.readLine(); push(Integer.parseInt(num)); } while(!isEmpty())System.out.println(pop()+" "); } } // أدخلي القيم التي تريدينها وستلاحظين أن الخرج سيحقق مفهوم المكدس طبعاً يمكنك تعديل الكود السابق وتغليفه مثلاً ضمن class تسميه Stack ويمكنك أن تضيف له العديد من الدوال الأخرى.
ويمكنك أيضاً استخدام الكلاس stack الذي تقدمه جافا وهو  كلاس يرث الصف vector وبالتالي يرث كل الدوال الموجودة فيها.
 
import java.util.Stack; // stack استيراد الصف public class Main { public static void main(String[] args) { // تعريف غرض من الصف Stack ourstack = new Stack(); // s هنا قمنا بإضافة 4 عناصر في الكائن ourstack.push("Ali"); ourstack.push("Ahmad") // إخراج البيانات من المكدس while( !s.empty() ) { System.out.println(ourstack.pop()); } } } ويوجد العديد من الدوال الأخرى ضمن الكلاس Stack في جافا.

# iterrows باستخدام الدالة for i, row in df.iterrows(): for j, column in row.iteritems(): print(column) # أو بالشكل التالي for index, row in df.iterrows(): print(row['column1'], row['column2']) # iloc أو باستخدام التابع for i in range(0, len(data)): print df.iloc[i]['column1'], df.iloc[i]['ccolumn2'] حيث أن الدالة iterrows هو مولد ينتج كلاً من الفهرس والسطر  (كسلسلة).

إن الـصف الابن يرث كل شيء موجود في الـصف الأب إلا الخصائص التي تم تعريفها كوسطاء بداخل الدالة __init__ و السبب في هذا أن  الدالة __init__  تولد الخصائص لل object و تربطها بالكلاس لحظة إنشاء ال object. أي إذا لم تنشئ كائن من الكلاس لن يتم إستدعاء هذه الدالة أصلاً أي يمكنك القول أن المتحولات المعرفة ضمنها لن تكون موجودة، لذا لايمكن وراثتها بشكل مباشر.
وحل هذه المشكلة يكون كما في المثال التالي، حيث نقوم باستدعاء الدالة __init__  للصف الأب داخل دالة __init__ للصف الابن:
class myname: def __init__(self,name="Esraa"): self.name=name # نقوم بوراثته class emp(myname): def __init__(self): myname.__init__(self) # نقوم باستدعاء باني الصف الاب داخل باني الصف الاب p = emp() # أخذ غرض من الصف الابن print(p.name) # Esraa  

هناك طرق كثيرة ويمكنك استخدام المكتبة Sikit-Learn لتنفيذها مباشرة:
1.Standardization: وهي العملية الأكثر شهرة , وفيها يتم طرح القيمة ناقص ال mean مقسومة علي الانحراف المعياري std.
# StandardScaler استيراد الصف from sklearn.preprocessing import StandardScaler # القيام بعملية التقييس StandardSca = StandardScaler(copy=True) #StandardScaler تعريف غرض من الصف # copy=True لكي لايعدل على البيانات الأساسية أي سينشئ نسخة عن البيانات ويطبق عليها التقييس data = StandardSca.fit_transform(data) # StandardScaler استدعاء التابع الذي ينفذ عملية التقييس من الصف 2.MinMaxScaler: يتم فيه طرح القيمة من المتوسط وتقسم على المدى (الفرق بين أكبر وأصغر قيمة) وتكون القيم الجديدة بين 0 و 1.
#MinMaxScaler استيراد الصف from sklearn.preprocessing import MinMaxScaler MinMaxSc = MinMaxScaler(copy=True, feature_range=(0, 1)) # يمكننا تغيير المجال data = MinMaxSc.fit_transform(data) 3.Binarizer: تقوم بتحويل القيم إلى 0 أو ، بناءان على قيمة العتبة threshold الممرة
from sklearn.preprocessing import Binarizer Binarize = Binarizer(threshold = value) data = Binarize.fit_transform(data) 4.Normalizer: مخصصة لتناول كل صف علي حدة في المصفوفات ثنائية الأبعاد.
from sklearn.preprocessing import Normalizer Normalize = Normalizer(copy=True, norm='l2') # max يمكنك تغيير النورم الى 11 أو data = Normalize.fit_transform(data) 5.FunctionTransformer:  للقيام  بالتقييس باستحدام دالة نعرفها بأنفسنا.
from sklearn.preprocessing import FunctionTransformer ''' FunctionTransformer(func=None, inverse_func=None, validate= None, accept_sparse=False,pass_y='deprecated', check_inverse=True, kw_args=None,inv_kw_args=None) ''' scaler = FunctionTransformer(func = lambda x: x**2,validate = True) data = scaler.fit_transform(data)  

تشير الأقواس المتعرجة {} إلى وجود Block أي نطاق محلي أو كتلة من التعليمات المترابطة.
فعندما نعرف حلقة تقوم بعمل تكرار لتعليمات معينة، نقوم بوضع هذه التعليمات ضمن Block أي ضمن {} ,والغاية من ذلك هو تحديد التعليمات التي ستتكرر، أي لكي يفهم الكومبايلر أين تبدأ التعليمات التي تريدها أن تتكرر وأين تنتهي.
for (int i = 0; i < 5; i++) { // هنا أنت تخبر الكومبايلر أن التعليمات التي تريد أن تكررها تبدأ من هنا System.out.println(i); // خمس مرات System.out.println(i) أي سيتم تنفيذ التعليمة } // وتنتهي هنا // for التعليمات التالية ليست ضمن القوسين المتعرجين لحلقة // أي طالما ليسوا ضمن القوسين فهما منفصلين عن الحلقة int x=5; System.out.println(x); أو عندما نعرف تابع فيجب أن نضع التعليمات التي يقوم بها هذا التابع ضمن Block أيضاُ، لكي يفهم الكومبايلر أين يبدأ التابع الخاص بك وأين ينتهي.
public void bar(int num1, int num2) { // أي هنا تبدأ التعليمات التي ينفذها التابع // تعليمة 1 // تعليمة 2 // تعليمة 3 } // وهنا تنتهي أما بالنسبة للأقواس من الشكل () فهذه الأقواس نستخدمها لكي نضع ضمنها الوسطاء التي يحتاجها تابع للقيام بمهمة ما، أو مثلاً المعلومات التي تحتاجها الحلقة لتقوم بعملية التكرار.
public sum bar(int num1, int num2) // () هنا وضعنا المعلومات التي يحتاجها التابع لكي يقوم بعمله ضمن { // تعليمة 1 // تعليمة 2 // تعليمة 3 } for (int i = 0; i < 5; i++) // وضعنا ضمن القوسين () المعلومات التي تحتاجها الحلقة { System.out.println(i); } الأقواس المربعة [] تستخدم لتعريف المصفوفات
int [] numbers; // أي قمنا بتعريف مصفوفة  

DB Diagram: تعرض مخططات قاعدة البيانات بنية قاعدة البيانات بشكل بياني. وذلك باستخدام رسوم تخطيطية لقاعدة البيانات.
حيث يمكنك من خلالها تمثيل ال Objects في جداول وتمثيل العلاقات بينها بالرسم.
مثال:

في One_Hot، يتم إعطاء كل كلمة w في مجموعة المفردات رقم تعريف فريد Wid يتراوح بين 1 و | V |، بحيث |V| هو عدد الكلمات المختلفة في مجموعة البيانات (عدد الكلمات المختلفة الكلي)، و V هي كل الكلمات المختلفة في مجموعة البيانات.
ثم يتم تمثيل كل كلمة بواسطة متجه قيمه من 0 و 1 وأبعاده تساوي |V| أي بعدد المفردات المختلفة، ومملوء ب صفر باستثناء الفهرس الذي يقابل رقم الكلمة index = wid، حيث نضع فيه 1.
ليكن لدينا المثال التالي :
D1 Dog bites man
D2 Man bites dog
D3 Dog eats meat
D4 Man eats food
نقوم أولاً بإعطاء رقم فريد لكل كلمة:
dog = 1, bites = 2, man = 3, meat = 4 , food = 5, eats = 6
نلاحظ أن V|=6|
لنأخذ أول نص من بياناتنا ونرمزه باستخدام One_Hot:
-يتم تمثيل dog  ك [1,0,0,0,0,0]
-يتم تمثيل bites ك [0,1,0,0,0,0]
-يتم تمثيل man ك [0,0,1,0,0,0]
وبالتالي يتم تمثيل D1 ك :  [[0,0,1,0,0,0],[0,1,0,0,0,0],[1,0,0,0,0,0]]  أو [1,1,1,0,0,0]
وهكذا بالنسبة للبقية.
سأعطي الآن مثال حقيقي وأرمزه باستخدام keras:
##################################################### By Ali #########################################333 # قمنا بتعريف عدة نصوص Text1='The Argentine national team will play tomorrow' Text2='The Brazil national team will travel to Hill' Text3='I Love' Text4='Champeons Leage' Text5='One hot Encoding is a type of vector representation ' data=[Text1,Text2,Text3,Text4,Text5] #list جمعنا هذه النصوص في print("The data :"data) ''' Tokenizer نقوم باستيراد الكلاس لها Tokenaization هذا الكلاس نعطيه البيانات ويقوم بعمل أي من خلاله سأقوم بإسناد رقم فريد لكل كلمة في النص وسأقوم أيضاً من خلاله بتمثيل النصوص على شكل أرقام ''' from keras.preprocessing.text import Tokenizer t= Tokenizer() t.fit_on_texts(data) # هنا سوف يأخذ كل البيانات ويربط كل كلمة بعدد صحيح فريد #هنا سيعرض لي القاموس الذي تم إنشاؤه لبياناتنا وهو قاموس يحتوي على كل كلمة مع العدد الصحيح الذي تم ربطها به print("The word index",t.word_index) # الآن نقوم بتحويل النصوص التي لدينا إلى نصوص مرمزة بأرقام على أساس قيم القاموس sequences = t.texts_to_sequences(data) print("The sequences generated from text are : ",sequences) # one hot encodingهناالتابع الذي سيحقق لي عملية ال import numpy as np def One_hot_encoded(sequences, dimension=24+1): # لأن عدد الكلمات المميزةهو 24 results = np.zeros((len(sequences), dimension)) for i, sequence in enumerate(sequences): results[i, sequence] = 1 return results # الآن نستدعي التابع One_Hot_data = One_hot_encoded(sequences) print("One Hot Encoding:\n"+str(One_Hot_data)) # END الخرج :
The word index {'the': 1, 'national': 2, 'team': 3, 'will': 4, 'argentine': 5, 'play': 6, 'tomorrow': 7, 'brazil': 8, 'travel': 9, 'to': 10, 'hill': 11, 'i': 12, 'love': 13, 'champeons': 14, 'leage': 15, 'one': 16, 'hot': 17, 'encoding': 18, 'is': 19, 'a': 20, 'type': 21, 'of': 22, 'vector': 23, 'representation': 24} The sequences generated from text are : [[1, 5, 2, 3, 4, 6, 7], [1, 8, 2, 3, 4, 9, 10, 11], [12, 13], [14, 15], [16, 17, 18, 19, 20, 21, 22, 23, 24]] One Hot Encoding: [[0. 1. 1. 1. 1. 1. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] [0. 1. 1. 1. 1. 0. 0. 0. 1. 1. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]  
-
 
 

ان مصدر البيانات متعدد اما ان يكون الكيبورد (وهو القياسي ) أو يكون ملف و ممكن ان يكون socket أي قراءة البيانات من الشبكة وفي جميع الحالات يتم التعامل مع هذه المصادر من خلال ما يسمى مجرى البيانات Stream، أما الكتابة ممكن أن تكون على الشاشة وممكن أن تكون كتابة الى ملف او الى جهاز اخر عبر ال Socket، وكذلك هذه العمليات تتم بنفس الطريقة من خلال ال Stream. إذاً الغاية من استخدام المجاري Stream هي توحيد عمليات الادخال والإخراج بغض النظر عن الهدف. وال Stream هو تدفق البيانات من مصدر الى الهدف .
وأنواع المجاري هي اما Byte Streams او Character Streams. حيث نوع البيانات التي سأنقلها من المصدر الى الهدف هي التي تحدد نوع المجرى الذي سأتعامل معه، مثلا عندما نقرا من ملف نصي فيجب أن نأخذ مجرى محرفي ( كل محرف من 16 بت ) اما عندما تكون البيانات ثنائية مثلا أغنية او فيديو أو... عندها نتعامل مع مجرى Byte Streams حيث كل بايت من 8 بتات.
بعد معرفة نوع المجرى يجب تحديد المجرى هل هو مجرى دخل أم خرج ؟ أي هل برنامج سوف يقرا بيانات ام سوف يكتب بيانات ؟
اذا كان البرنامج يريد أن يقرا بيانات ثنائية فهو يتعامل مع Input Stream اما اذا كان البرنامج يريد أن يقرا بيانات محرفية فهو يتعامل مع Reader.
اذا كان البرنامج يريد أن يكتب بيانات ثنائية فهو يتعامل مع Output Stream اما اذا كان البرنامج يريد أن يكتب بيانات محرفية فهو يتعامل مع Writer.

يجب تقسيم الملف ثم حفظه في أكثر من sheet ضمن ملف اكسيل واحد، لأن حجم الملف كبير وبالنسبة لملفات اكسل فإن اعلى حد للتخزين هو 1048576، الكود التالي يحل كل مشكلتك:
# قسم الملف لأكثر من قسم 4 أقسام مثلاً nr=r.shape[0]//4 r1=r.iloc[:nr][:] r2=r.iloc[nr:2*nr][:] r3=r.iloc[nr*2:3*nr][:] r4=r.iloc[3*nr:][:] # تخزين الأقسام writer.book.use_zip64() n=input("enter new file name\n") writer = pd.ExcelWriter('{}.xlsx'.format(n), engine='xlsxwriter',options={'strings_to_urls': False}) r1.to_excel(writer, 'Sheet1') r2.to_excel(writer, 'Sheet2') r3.to_excel(writer, 'Sheet3') r4.to_excel(writer, 'Sheet4') writer.save()  

للقيام بنقل التعلم "Transfer Learning" نقوم بقطع الطبقة الأخيرة من الشبكة المدربة مسبقاً ثم نستبدلها بطبقة أو بعدة طبقات تتناسب مع مشكلتنا وهنا في المقالة التي أشرت إليها هي VGG16 وهي شبكة عصبية مدربة على مجموعة بيانات Imagenet لتصنيف مايقارب ال 1000 فئة، أي أن الطبقة الأخيرة هي softmax والخرج هو توزيع احتمالي على 1000 فئة.
لذا نقوم بقطع طبقة ال softmax  هذه واستبدالها ب Block يتناسب مع مشكلتنا (المشكلة التي لديك هي تصنيف ثنائي لذا يمكنك استبدالها مثلاً ب Block مكون من طبقتين FC وطبقة خرج مكونة من خلية واحدة بتابع تنشيط Sigmoid)
النموذج المقطوع (أي النموذج كله ماعدا الطبقة التي أضفتها) سيكون خرجه هو ال features  التي يستخدمها ال Block الذي أضفته، هذه ال features  تسمى bottleneck features.

عندما يوفر المخدم (Remote Machine) خدمة جديدة ما ، لنعتبر أن هذه الخدمة هي عبارة عن صف ، فإنه يأخذ غرض من هذا الصف ويسجله في ال Registry ، يمكن تخيل ال Registry على أنها دفتر هواتف ،بحيث أننا إذا كنا نريد رقم شخص ما فإننا نبحث عن اسمه في دفتر الهواتف ثم نحصل على رقمه ، وهنا الأمر مشابه قإننا نبحث عن اسم الخدمة في ال Registry ثم نحصل على مرجع هذه الخدمة (الغرض البعيد) لنستخدمه.
تسجيل الخدمة (الغرض ) في ال Registry من قبل المخدم تسمى bind (يعطي لكل غرض مسار فريد). 
البحث عن خدمة ما في ال Registry من قبل الزبون تسمى Lookup .
وفي هذه المرحلة بعد حصول الزبون على مرجع الغرض البعيد فإنه يصبح قادر على أن يستدعي هذه الطرائق البعيدة الموجودة في الصف البعيد في النخدم.
عندما يستدعي الزبون أي طريقة بعيدة فإن هذا الاستدعاء يحول إلى stup (الوكيل Proxy من طرف الزبون) والذي يقوم بتمريره إلى Skeleton والذي يمرر الاستدعاء إلى المخدم. 

قبل رفع تطبيقات الويب على سيرفر موصول بشكل دائم بالشبكة ليحصل في النهاية على اسم نطاق مثلاً مثل hsoub.com ، يتم تجريب وتطوير هذه التطبيقات في بيئة محلية معتبرين أن الجهاز نفسه هو سرفر وزبون في نفس الوقت.
localhost هو السرفر المحلي الذي نقوم بتجاربنا عليه مبدئياً قبل طرح المنتج البرمجي ليكون قيد التنفيذ الفعلي في سرفر نظامي.

plt.scatter(X[0, :], X[1, :], c=Y.reshape(X[0,:].shape), s=40, cmap=plt.cm.Spectral); #or plt.scatter(X[0, :], X[1, :], c=Y.reshape(X[1,:].shape), s=40, cmap=plt.cm.Spectral); #or plt.scatter(X[0, :], X[1, :], c=Y.reshape(X.shape[0]), s=40, cmap=plt.cm.Spectral); #or plt.scatter(X[0, :], X[1, :], c=Y.reshape(X.shape[1]), s=40, cmap=plt.cm.Spectral); - plt.scatter هو تابع يأخذ مصفوفتين كدخل، الأولى تمثل المحور السيني والثانية تمثل المحور العيني وتمثلهم كنقط بالمستوي الاحداثي.
- هذه النقط يمكن أن تلونها باستخدام الخرائط اللونية. 
- cmap هي خريطة لونية وكل لون فيها له index.
-كل نقطة سوف تأخذ لون من الخريطة cmap هذا اللون سوف يكون بناءان على قيمة c مثلاً إذا كانت c=0  هذا يعني أن النقطة ستأخذ اللون المقابل لل index=0  وهكذا ..
- لدينا 400  نقطة حسب X لذا يجب أن نسند ل c  أربعمئة قيمة، هذه القيم سوف تؤخذ من Y لذا يجب ضبط أبعاد المصفوفة Y بحيث تكون بنفس أبعاد [:,0]X أو X[1,:].

class MyClass: def __init__(self): self.lst = [] بايثون تقدم نوعين لل  attributes هما : class attributes and instance attributes.
ال class attributes تشبه كثيراً ال static attributes في جافا و c++ فهي تتشارك نفس القيمة مع كل ال object  التي تؤخذ من هذا الصف، ويتم تعريف  ال class attributes في بايثون تماماً كما قمت أنت بتعريف المتغير الذي سميته  lst  لذا فكانت القيم هي نفسها.

أما ال instance attributes فهي متغير ينتمي إلى object  واحد فقط أي أن كل متغير تعرفه ك  instance attributes سوف تكون قيمه منفصلة في كل object  تأخذه من هذا الصف ، ويتم تعريف ال  instance attributes تماماً كما عرفتها لك أنا أي ضمن التابع init

# GRADED FUNCTION: forward_propagation_with_dropout def forward_propagation_with_dropout(X, parameters, keep_prob=0.5): np.random.seed(1) # retrieve parameters W1 = parameters["W1"] b1 = parameters["b1"] W2 = parameters["W2"] b2 = parameters["b2"] W3 = parameters["W3"] b3 = parameters["b3"] # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID Z1 = np.dot(W1, X) + b1 A1 = relu(Z1) ### START CODE HERE ### (approx. 4 lines) D1 = np.random.rand(A1.shape[0], A1.shape[1]) # A1 تعريف مصفوفة بقيم عشوائية بين الصفر والواحد وبنفس أبعاد المصفوفة D1 = D1 < keep_prob A1 = A1 * D1 A1 = A1 / keep_prob ### END CODE HERE ### Z2 = np.dot(W2, A1) + b2 A2 = relu(Z2) ### START CODE HERE ### (approx. 4 lines) D2 = np.random.rand(A2.shape[0], A2.shape[1]) D2 = D2 < keep_prob A2 = A2 * D2 A2 = A2 / keep_prob ### END CODE HERE ### Z3 = np.dot(W3, A2) + b3 A3 = sigmoid(Z3) cache = (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3) return A3, cache نعرف مصفوفة بقيم عشوائية بنفس أبعاد المصفوفة A ثم تحويل قيم المصفوفة D1 إلى 0 أو 1 حسب الشرط ( إذا كانت القيمة الأولى في المصفوفة D1 مثلاً 0.2 وهي أقل من العتبة (keep_prob = 0.5) أي سيكون الشرط محقق (D1<keep_porb) وسيقوم بتحويل القيمة إلى  1 , والعكس صحيح وسيقوم بتحويل القيمة إلى 0 ثم ضرب المصفوفة A1 بـ D1 بعد تعديل قيمها إلى 0,1 ثم تقسيم قيم المصفوفة A1 على العتبة....

1.ادخل إلى start menue.
2.اكتب في مربع البحث "registry editor" ثم ادخل إليه.
3. من الواجهة التي تظهر انتقل إلى : "HKEY_CURRENT_USER\SOFTWARE\Classes\Directory\Background\shell".
ملاحظة 1: إذا لم يكن المجلد shell موجوداً، قم بإنشائه عن طريق الضغط  بالزر اليميني على Background ثم اختر new ثم key ثم سينشئ لك مجلد ويطلب منك تسميته (قم بتسميته shell).
ملاحظة 2: يمكنك تتبع الصور.
4.بعد ذلك انقر بالزر اليميني على shell واختر new ثم key سمي المجلد الذي سينتج Bash.
5.الآن على يمين الشاشة اضغط بالزر اليميني على البيانات التي تسمى "Deafult" (تسمى القيمة value)  ثم اختر modify ثم اكتب open in bash (هذا الاسم هو الذي سيظهر على سطح المكتب عندما تضغط على المجلد الذي تريده).
6.اضغط بالزر اليميني على bash واختر  new  ثم key وسمي المجلد الذي سينتج command.
7.اضغط بالزر اليميني على ال value واختر modify ثم ضع المسار الذي يوجد به التطبيق الخاص بك .
8. الآن اذهب لسطح المكتب واضغط بالزر اليميني على أي مجلد وستراه.