بايثون هي لغة برمجة متعددة الأغراض، تعمل على عدد من المنصات مثل ويندوز (Windows) و ماك (Mac OS X) و لينوكس (Linux). وهو برنامج مجاني مفتوح المصدر. يمكن الحصول على احدث نسخة من البرنامج من خلال الموقع.

اولاً: العمليات الحسابية

في البداية سوف نستعرض العمليات الرياضية في برنامج بايثون من خلال الجدول التالي:

ثانياً: العمليات المنطقية

كما أن عمليات المنطقية تعطى بواسطة الجدول التالي:

فمثلاً:

In:
5>4
Out:
True
In:
2>3
Out:
False
In:
2==2
True
In:
3!=2
Out:
True

كذلك تعطى العمليات المنطقية كما يلي:

مثلاً:

In:
x=2
y=3
x==2 and y==2
Out:
False
In:
x==2 or y==2
Out:
True
In:
not y==2
Out:
True

ثالثاً: عمليات التعريف

كما أن عمليات التعريف (is , is not) يمكن أن تستخدم كما في المثال التالي:

In:
x=2
x is 2
Out:
True
In:
x is 3
Out:
False
In:
x is not 3
Out:
True

رابعاً: عمليات الإنتماء

وعمليات الإنتماء (in , not in) تستخدم كما يلي:

In:
x=(2,3,4)
2 in x
Out:
True
In:
5 in x
Out:
False
In:
5 not in x
Out:
True

خامساً: انواع البيانات

انواع البيانات في برنامج بايثون هي:

[1,2,'Aziz']

(1,2,'Aziz')

"Aziz blog"

{1,2,'Aziz'}

{"A": "apple","C": "car","P":"Person" }

في هذا المقال سوف نستعرض كيف يمكن قراءة ملفات البيانات بأنواعها المختلفة باستخدام لغة البرمجة بايثون. في البداية نحتاج إلى تحديد دليل العمل (working directory) – موقع الملفات التي سوف نقوم بقراءتها كما يلي:

In:
import os
os.chdir('*****')

ثم بعد ذلك يمكن استخدام الطرق التالية:

أولاً: قراءة ملف csv

فمثلاً لقراءة ملف البيانات mydata يمكن استخدام الكود التالي:

In:
import pandas as pd
mydata = pd.read_csv('mydata.csv',sep=',',header=0)
print(mydata.iloc[0:2,])
Out:
       name  age    city
0       Ali   20  Riyadh
1  Mohammed   30  Jeddah

حيث هناك عدد من الخيارات تتحكم في مخرج الدالة pd.read_csv ومن أهمها:

فمثلاً، لتعديل أسماء الأعمدة في المثال أعلاه يمكن استخدام الكود:

In:
mydata = pd.read_csv('mydata.csv',sep=',',header=0,names=['first name', 'working years','working city'])
print(mydata.iloc[0:2,])
Out:
  first name  working years working city
0        Ali             20       Riyadh
1   Mohammed             30       Jeddah

ثانيا: قراءة ملف txt

فمثلا لقراءة ملف mydata يمكن استخدام الكود التالي:

In:
mydata = pd.read_csv('mydata.txt',sep="\t",header=0)
print(mydata.iloc[0:2,])
Out:
       name  age    city
0       Ali   20  Riyadh
1  Mohammed   30  Jeddah

ثالثاً: قراءة ملف json

فمثلا لقراءة ملف البيانات mydata  يمكن استخدام الكود التالي:

In:
mydata = pd.read_json('mydata.json')
print(mydata.iloc[0:2,])
Out:
       name  age    city
0       Ali   20  Riyadh
1  Mohammed   30  Jeddah

تعتبر القائمة (list) احد انواع هياكل البيانات شائعة الاستخدام في في لغة البرمجة بايثون والتي يمكن أن تحوي انواع مختلفة من البيانات تشمل الرقمية مثل int,float او النصية string او أنواع اخرى مثل: object,datetime ويمكن أن أيضاً تحوي مجموعة من القوائم (lists) او مجموعة من القواميس dictionaries، وذلك كما في الجدول التالي:

الفهرس (index) هو عبارة عن رقم يعبر عن مكان العنصر في القائمة (list). حيث أن list[0] يمثل العنصر الاول و list[1] يمثل العنصر الثاني وهكذا. وكذلك يمكن ان نستخدم الفهرس بالسالب فيكون list[-1] هو آخر عنصر في القائمة و list[-2] هو العنصر قبل الأخير وهكذا حتى البداية. فمثلاً:

In:
mylist=[2,5,4]
mylist[0]
Out:
2
In:
mylist[-3]
Out:
2
In:
mylist[-1]
Out:
4

هناك عدد العمليات التي يمكن تنفيذها على القائمة ويمكن تلخيصها كما يلي:

اولاً: دوال الإضافة

1. دالة ()append والتي تستخدم لإضافة عنصر في اخر القائمة:

In:
mylist=[2,5,4]
mylist.append(7)
mylist
Out:
[2, 5, 4, 7]

2. دالة ()insert تستخدم لإضافة عنصر في مكان محدد في القائمة وتأخذ الصيغة التالية:
list.insert(index, element)
وتستخدم كما يلي:

In:
mylist=[2,5,4]
mylist.insert(1, 7)
mylist
Out:
[2, 7, 5, 4]

3. دالة ()extend والتي تستخدم لإضافة قائمة الى قائمة أخرى:

In:
mylist=[2,5,4]
newlist=[-3,-6]
mylist.extend(newlist)
mylist
Out:
[2, 5, 4, -3, -6]

ثانياً: دوال الحذف

1. دالة ()clear والتي قوم بمسح جميع عناصر القائمة:

In:
mylist=[2,5,4]
mylist.clear()
mylist
Out:
[]

2. دالة ()remove والتي تقوم بحذف عنصر محدد من القائمة وتاخذ قيمة العنصر المراد حذفه:

In:
mylist=[2,5,4]
mylist.remove(5)
mylist
Out:
[2, 4]

3. دالة ()pop والتي تحذف اخر عنصر من القائمة ولا تأخذ فهرس (index) في هذه الحالة. او تحذف عنصر من مكان محدد عن طريق اخذ فهرس العنصر المراد حذفه:

In:
mylist=[2,5,4]
mylist.pop()
mylist
Out:
[2, 5]
In:
mylist=[2,5,4]
mylist.pop(1)
mylist
Out:
[2, 4]

ثالثاً: دوال أخرى

1. دالة ()count والتي تقوم بحساب عدد مرات تكرار عنصر معين في القائمة:

In:
mylist=[4,2,5,4]
mylist.count(4)
Out:
2

2. دالة ()sort والتي تقوم بترتيب عناصر القائمة تصاعدياً او تنازلياً:

In:
mylist=[2,5,4,1,3]
mylist.sort()
mylist
Out:
[1, 2, 3, 4, 5]
In:
mylist=[2,5,4,1,3]
mylist.sort(reverse=True)
mylist
Out:
[5, 4, 3, 2, 1]

3. دالة ()copy والتي تقوم بنسخ عناصر القائمة الي قائمة اخرى:

In:
mylist=[2,5,4]
newlist=mylist.copy()
newlist
Out:
[2, 5, 4]

4. دالة ()index والتي تأخذ قيمة عنصر محدد ثم تقوم تحديد الفهرس (index) الخاص به:

In:
mylist=[2,5,4]
mylist.index(4)
Out:
2

ملاحظة: كذلك يمكن استخدام الدوال العامة في بايثون مع القائمة فمثلاً مع القائمة:

mylist=[2,5,4]

يمكن استتخدام:

سوف نستعرض في هذا المقال بعض دوال مكتبة pandas التي يمكن استخدامها لاستخراج خصائص البيانات (feature engineering). لتوضيح ذلك سوف نستخدم البيانات  بيانات الأزمة الاقتصادية والمصرفية لأفريقيا [1]. في البداية سوف نقوم باستيراد البيانات كما يلي:

In:
import pandas as pd
african_crises = pd.read_csv("african_crises.csv")

بعد ذلك نستعرض عدد من النقاط  ذات العلاقة بالاستخراج خصائص البيانات ونوضح طريقة التعامل معها وهي كما يلي:

أولاُ: تحويل المتغيرات الأسمية (Nominal variables) الى متغيرات عددية (numeric variables)

لتحويل المتغيرات الأسمية الى متغيرات عددية يمكن استخدام الدالة:
df.replace(to_replace=None, value=None, inplace=False, ...)
والتي تقوم باستبدال القيم الحالية في إطار البيانات (df) بقيمة اخرى من خلال إنشاء متغير جديد عندما يكون inplace=False او استبدال القيمة في نفس موقعها عندما يكون inplace=True، وذلك كما في المثال التالي:

In:
african_crises['encoded_banking_crisis']  = african_crises['banking_crisis'].replace({'crisis':1,'no_crisis':0})
african_crises[['encoded_banking_crisis','banking_crisis']].head()
Out:
   encoded_banking_crisis banking_crisis
0                       1         crisis
1                       0      no_crisis
2                       0      no_crisis
3                       0      no_crisis
4                       0      no_crisis

ثانياً: تحويل المتغيرات الفئوية (categorical variables) إلى وهمية (dummy variables)

لتحويل المتغيرات الفئوية الى وهمية يمكن استخدام  الدالة:
pd.get_dummies(data, ...)
وذلك كما في الكود التالي:

In:
Dumm_banking_crisis = pd.get_dummies(african_crises['banking_crisis'])
Dumm_banking_crisis=pd.concat([african_crises['banking_crisis'], Dumm_banking_crisis], axis=1)
Dumm_banking_crisis.head()
Out:
  banking_crisis  crisis  no_crisis
0         crisis       1          0
1      no_crisis       0          1
2      no_crisis       0          1
3      no_crisis       0          1
4      no_crisis       0          1

ثالثاً: حساب عدد القيم الفريدة (unique values) لمتغير.

لحساب عدد القيم الفريدة يمكن استخدام الدالة:
Series.value_counts(normalize=False,ascending=False, dropna=True, ...)
والتي تعطي عدد القيم الفريدة في سلسلة (Series) بترتيب تنازلي بحيث يكون العنصر الأول هو العنصر الأكثر تكرارا، كذلك يتم استبعاد القيم المفقودة (NA) بشكل افتراضي. إذا كان normalize=True فإن مخرجات الدالة هي التكرارات النسبية للقيم الفريدة. ويمكن استخدام هذه الدالة كما يلي:

In:
country_freq = african_crises['country'].value_counts()
country_freq
Out:
Egypt                       155
South Africa                114
Zimbabwe                     90
Algeria                      85
Angola                       77
Tunisia                      75
Morocco                      75
Zambia                       72
Mauritius                    68
Kenya                        67
Ivory Coast                  63
Nigeria                      60
Central African Republic     58

رابعاً: تقسيم متغير الى فئات (Quantile-based discretization)

لتقسيم متغير الى فئات يمكن استخدام الدالة:
pd.qcut(x, q, labels=None, ...)
والتي تقوم بتقسيم المتغير x إلى فئات متساوية الحجم عددها q  ومسمياتها labels بناء على الرتبة أو بناء على تقسيمات العينة (sample quantiles) وذلك كما في المثال التالي:

In:
level = ['Very Low', 'Low', 'Med', 'High', 'Very High']
african_crises['inflation_annual_cpi_level'] = pd.qcut(african_crises['inflation_annual_cpi'], q=5, labels=level)
african_crises[['inflation_annual_cpi', 'inflation_annual_cpi_level']].head()
Out:
   inflation_annual_cpi inflation_annual_cpi_level
0              3.441456                        Low
1             14.149140                  Very High
2             -3.718593                   Very Low
3             11.203897                       High
4             -3.848561                   Very Low

كذلك يمكن استخدام الدالة:
pd.cut(x, bins, labels=None, ...)
والي تقوم بتقسيم متغير x الى فئات حدودها bins ومسمياتها labels كما في الكود التالي:

In:
level = ['Very Low', 'Low', 'Med', 'High', 'Very High']
bins = [-18, -1, 3 ,10 , 15, 30]
african_crises['inflation_annual_cpi_level'] = pd.cut(african_crises['inflation_annual_cpi'], bins=bins, labels=level)
african_crises[['inflation_annual_cpi', 'inflation_annual_cpi_level']].head()
Out:
  inflation_annual_cpi inflation_annual_cpi_level
0              3.441456                        Med
1             14.149140                       High
2             -3.718593                   Very Low
3             11.203897                       High
4             -3.848561                   Very Low

خامساً: تجميع البيانات (grouping data)

لتجميع البيانات يمكن استخدام الدالة:
df.groupby(by=None, ...)
والتي تقوم بتجميع البيانات (df) حسب متغير او مجموعة متغيرات، حيث يمكن اجراء العمليات الحسابية أو الإحصائية على هذه المجموعات. فمثلاً، لحساب المتوسط الحسابي لسعر الصرف مقابل الدولار الأمريكي في كل دولة يمكن استخدام الكود:

In:
african_crises.groupby(['country'])['exch_usd'].mean()
Out:
country
Algeria                      20.177565
Angola                       15.099671
Central African Republic    367.686066
Egypt                         1.006045
Ivory Coast                 153.320635
Kenya                        30.713180
Mauritius                    13.759661
Morocco                       5.865309
Nigeria                      38.951022
South Africa                  1.719339
Tunisia                      50.692807
Zambia                        1.116342
Zimbabwe                     20.207800

سادساً: العمليات الإحصائية (Statistical operations)

لاجراء عدد من العمليات الإحصائية على متغير او أكثر في إطار البيانات يمكن استخدام الدوال التالية:

وذلك كما في المثال التالي:

In:
print("The max of exch_usd is: ",african_crises.exch_usd.max())
print("The min of exch_usd is: ",african_crises.exch_usd.min())
print("The count of exch_usd is: ",african_crises.exch_usd.count())
print("The sum of exch_usd is: ",african_crises.exch_usd.sum())
print("The mean of exch_usd is: ",african_crises.exch_usd.mean())
print("The median of exch_usd is: ",african_crises.exch_usd.median ())
Out:
The max of exch_usd is:  744.3061387
The min of exch_usd is:  0.0
The count of exch_usd is:  1059
The sum of exch_usd is:  45686.1396807569
The mean of exch_usd is:  43.14083067115856
The median of exch_usd is:  0.8684

[1] مصدر البيانات:  kaggle

قاموس البيانات (dictionary) في لغة البرمجة بايثون هو أحد هياكل البيانات التي تستخدم لتخزين بيانات مترابطة ببعضها. يحوي القاموس مجموعة من المفاتيح (key) والقيم (value) حيث ان كل مفتاح له قيمة وتكون المفاتيح فريدة اي لا يكمن ان تتكرر. فمثلا، هذا قاموس يحوي أسماء البلدان كمفاتيح والعواصم كقيم:

data = {'Saudi': 'Riyadh', 'Egypt': 'Cairo', 'France': 'Paris'}

كذلك، هذا قاموس بأسماء الطلاب ومعدلاتهم الدراسية:

data = {'Student': ['Ahmed', 'Mohamed', 'Ali'], 'GPA': ['70%', '80%', '90%']}

ويمكن التعامل مع البيانات في القاموس من خلال عدد من الدوال يمكن تلخيص أهمها كما يلي:

أولاً: استخراج قيمة المفتاح إذا كان المفتاح موجودًا في القاموس ويتم ذلك من خلال الدالة get كما يلي:

In:
data = {'Saudi': 'Riyadh', 'Egypt': 'Cairo', 'France': 'Paris'}
data.get('Egypt')
Out:
'Cairo'

او باستخدام الفهرس (index) كما يلي:

In:
data['Saudi']
Out:
'Riyadh'

ثانياً: تحديث قيمة موجودة في القاموس  وذلك كما يلي:

In:
data['Saudi']='الرياض'
print(data)
Out:
{'Saudi': 'الرياض', 'Egypt': 'Cairo', 'France': 'Paris'}

كما يمكن إضافة قيمة جديدة كما يلي:

In:
data['UK']='London'
print(data)
Out:
{'Saudi': 'Riyadh', 'Egypt': 'Cairo', 'France': 'Paris', 'UK': 'London'}

كذلك يمكن تحديث عدة عناصر باستخدام الدالة update كما يلي:

In:
data.update({'Egypt': 'القاهرة', 'France': 'باريس'})
print(data)
Out:
{'Saudi': 'الرياض', 'Egypt': 'القاهرة', 'France': 'باريس', 'UK': 'London'}

أو إضافة عدة عناصر كما يلي:

In:
data.update({'Emirates': 'Abu Dhabi', 'Bahrain': 'Manama'})
print(data)
Out:
{'Saudi': 'الرياض', 'Egypt': 'القاهرة', 'France': 'باريس', 'UK': 'London', 'Emirates': 'Abu Dhabi', 'Bahrain': 'Manama'}

ثالثاً: حذف اخر عنصر (مفتاح وقيمته) من القاموس وذلك باستخدام الدالة popitem كما يلي:

In:
data.popitem()
print(data)
Out:
{'Saudi': 'الرياض', 'Egypt': 'القاهرة', 'France': 'باريس', 'UK': 'London', 'Emirates': 'Abu Dhabi'}

أو حذف عنصر محدد من القاموس باستخدام الدالة pop كما يلي:

In:
data.pop('France')
print(data)
Out:
{'Saudi': 'الرياض', 'Egypt': 'القاهرة', 'UK': 'London', 'Emirates': 'Abu Dhabi'}

رابعاً: استخراج جميع مفاتيح القاموس:

In:
data.keys()
Out:
dict_keys(['Saudi', 'Egypt', 'UK', 'Emirates'])

خامساً: استخراج جميع قيم القاموس:

In:
data.values()
Out:
dict_values(['الرياض', 'القاهرة', 'London', 'Abu Dhabi'])

في هذا المقال سوف نستعرض طريقة التعامل مع البيانات المتكررة باستخدام لغة البرمجة بايثون. في البداية سوف نستخدم البيانات، ثم نستخدام الكود التالي لتحديد دليل العمل (working directory):

In:
import os
os.chdir('*****')

ثم نقوم باستيراد البيانات كما يلي:

In:
import pandas as pd
mydata = pd.read_csv('mydata.csv')
print(mydata)
Out:
       name  age      city
0       Ali   20    Riyadh
1  Mohammed   30    Jeddah
2     Ahmed   33  Alkhobar
3       Ali   20    Riyadh
4    Bander   43   Dammam 
5       Ali   20    Riyadh
6  Mohammed   30    Jeddah
7  Abdullah   38    Riyadh
8    Khaled   30    Jeddah

لتوضيح التكرار في البيانات نقوم بفرز (sort) البيانات كما يلي:

In:
mydata=mydata.sort_values(by=['name','age','city'])
print(mydata)
Out:
      name  age      city
7  Abdullah   38    Riyadh
2     Ahmed   33  Alkhobar
0       Ali   20    Riyadh
3       Ali   20    Riyadh
5       Ali   20    Riyadh
4    Bander   43   Dammam 
8    Khaled   30    Jeddah
1  Mohammed   30    Jeddah
6  Mohammed   30    Jeddah

وبعد ذلك يمكن حذف البيانات المتكررة باستخدم الدالة التالية:
df.drop_duplicates(subset, keep, inplace, ignore_index)

حيث أن:

وذلك كما في الأمثلة التالية:

1. حذف الصفوف المتكررة مع إبقاء  أول صف منها:

In:
newdata=mydata.drop_duplicates()
print(newdata)
Out:
       name  age      city
7  Abdullah   38    Riyadh
2     Ahmed   33  Alkhobar
0       Ali   20    Riyadh
4    Bander   43   Dammam 
8    Khaled   30    Jeddah
1  Mohammed   30    Jeddah

2. حذف الصفوف المتكررة وإبقاء أخر صف منها

In:
newdata=mydata.drop_duplicates(subset=['name'],keep='last')
print(newdata)
Out:
       name  age      city
7  Abdullah   38    Riyadh
2     Ahmed   33  Alkhobar
5       Ali   20    Riyadh
4    Bander   43   Dammam 
8    Khaled   30    Jeddah
6  Mohammed   30    Jeddah

3. حذف الصفوف المتكررة جميعها

In:
newdata=mydata.drop_duplicates(keep=False)
print(newdata)
Out:
       name  age      city
7  Abdullah   38    Riyadh
2     Ahmed   33  Alkhobar
4    Bander   43   Dammam 
8    Khaled   30    Jeddah

4. حذف الصفوف المتكررة وفقاً لعمود معين أو أكثر

In:
newdata=mydata.drop_duplicates(subset=['name'],keep=False)
print(newdata)
Out:
      name  age      city
7  Abdullah   38    Riyadh
2     Ahmed   33  Alkhobar
4    Bander   43   Dammam 
8    Khaled   30    Jeddah

في بايثون هناك عدة طرق لأخذ عينة (sampling) من البيانات سنبدأ بأخذ عينة من البيانات بدون إرجاع، وفي هذه الحالة يجب أن يكون حجم العينة أصغر من حجم البيانات. ويتضح ذلك من خلال الأمثلة التالية:

In:
import random as r

x = [1, 2, 3, 4, 5] 
s=r.sample(x,5)
print(s)
Out:
[4, 1, 5, 3, 2]

لاختيار عينة من سلسلة من الكلمات:

In:
x = ["Ali", "Mohammed", "Khalid", "Sultan"]
s=r.sample(x,3)
print(s)
Out:
['Mohammed', 'Khalid', 'Ali']

لاختيار عينة من سلسلة من الحروف:

In:
x = "Data"
s=r.sample(x,3)
print(s)
Out:
['a', 'D', 'a']

لاختيار عينة من قاموس البيانات:

In:
x  = {
  "Ali": 55,
  "Mohammed": 70,
  "Khalid": 60,
  "Sultan" :50
}
s=r.sample(x.items(),3)
print(s)
Out:
[('Mohammed', 70), ('Khalid', 60), ('Sultan', 50)]

للحصول على خيارات أكثر بخصوص خاصية الإرجاع واحتمالية اختيار عنصر محدد في العينة وهنا لا يشترط أن يكون حجم العينة أصغر من حجم البيانات، يمكن استخدام الكود التالي:

In:
import numpy as np
x = [1, 2, 3]
np.random.choice(x, size=2, replace=True, p=(0.3,0.6,0.1))
Out:
array([2, 2])

لأخذ عينة من إطار البيانات (data frame) مع المحافظة على تقابل عناصر الصفوف يمكن استخدام الكود التالي:

In:
import pandas as pd

mydata = pd.DataFrame({'x': [1, 2, 3, 4, 5], 'y': ['a', 'b', 'c', 'd', 'e']})
mydata.sample(n=3, replace=False)
Out:
   x  y
2  3  c
0  1  a
4  5  e

هناك عدة طرق لحفظ إطار البيانات (data frame) من حزمة pandas الى ملفات بصيغ مختلفة في بايثون، سوف نلخص بعض منها في هذ المقال. في البداية سوف نحدد دليل العمل الذي سوف يتم حفظ أي ملف فيه بإستخدام الكود التالي:

In:
import os
os.chdir('****')

نفرض أن لدينا البيانات التالية:

In:
import pandas as pd
Student="Ali","Ahmed","Mohammed","Aziz"
Score= 100,95,80,77
list=list(zip(Student, Score))
mydata=pd.DataFrame(list,columns=['Student','Score'])
mydata
Out:
    Student  Score
0       Ali    100
1     Ahmed     95
2  Mohammed     80
3      Aziz     77

اولاً: حفظ ملف اكسل(csv) 

لحفظ هذه البيانات الى ملف بصيغة csv يمكن إستخدام الكود التالي:

In:
mydata.to_csv ('myfile.csv', index = None, header=True)

ثانياً: حفظ ملف نصي (txt)

لحفظ البيانات الى ملف نصي يمكن استخدام الكود التالي:

In:
f = open( 'myfile.txt', 'w' )
f.write( repr(mydata) + '\n' )
f.close()

ثالثاً: حفظ ملف جيسون (json)

لحفظ البيانات الى ملف جيسون يمكن استخدام الكود التالي:

In:
mydata.to_json('myfile.json',orient='records')

للكتابة الى ملف في لغة البرمجة بايثون هناك عدة خيارات سوف يتم مناقشتها كما يلي:

اولاً: الكتابة الى ملف جديد

يتم إنشاء ملف جديد ويتم الكتابة عليه باستخدام الكود التالي:

In:
out="Aziz"
with open("myfile.txt", 'w') as outfile:
    outfile.write(out)

في حالة وجود ملف بنفس الأسم يتم الكتابة عليه، بمعنى يحذف الملف الموجود ويتم إنشاء ملف جديد.

ثانياً: الكتابة الى ملف موجود

للكتابة الى ملف موجود يمكن استخدام الكود التالي:

In:
out="\n Mohammed"
with open("myfile.txt", 'a') as outfile:
    outfile.write(out)

في هذه الحالة لايتم حدف الملف الموجود او محتواه، ولكن يتم إضافة محتوى جديد اليه (appending mode). تم استخدام n\ لادراج سطر جديد.

ثالثاً: الكتابة الى ملفات بأسماء مختلفة ضمن حلقة تكرار 

لإنشاء ملفات بأسماء مختلفة ضمن حلقة تكرار والكتابة اليها يمكن استخدام الكود:

In:
for i in range(0,2):
    out='Aziz','Mohammed'
    with open("file{0}.txt".format(i), 'w') as outfile:
        outfile.write(out[i])

ملاحظات هامة:

1- لتحديد دليل العمل (work directory) الى موقع إنشاء الملف او الملفات:

In:
import os 
os.chdir('*****')

2- لقراءة ملف موجود يمكن استخدام:

In:
with open('myfile.txt', 'r') as outfile:
    print(outfile.read())

اولاً: تحديد دليل العمل (work directory) الى المجلد الذي يحوي الملفات

In:
import os 
os.chdir('myfolder')

ثانياً: نفرض أن لدينا عدة ملفات نصية (txt) في مجلد myfolder والمطلوب دمجمها في ملف واحد اسمه newdata، للقيام بذلك نستخدم الكود التالي:

In:
from glob import glob
with open('newdata.txt', 'w') as outfile:
    for fname in glob('*.txt'):
        print('Adding', fname)
        with open(fname) as infile:
           outfile.write(infile.read())

ملاحظة: في حال كانت الملفات ذات امتداد csv يمكن استبدال txt بـ csv.

عند استخدام بيانات تحوي مسميات باللغة العربية في بايثون فأنها تعرض بشكل معكوس ومفصل خصوصاً في الرسوم البيانية. في هذا المقال سوف نستعرض بالخطوات كيفية التعامل مع هذه المشكلة وذلك من خلال الخطوات التالية:

اولاً: تحميل الحزم التالية:

In:
!python -m pip install arabic_reshaper
!python -m pip install python-bidi

ثانيا: استخدام الكود التالي:

In:
from arabic_reshaper import arabic_reshaper
from bidi.algorithm import get_display

ثالثاً: تعريف الدالة التالية:

In:
def f(x):
    out=get_display( arabic_reshaper.reshape(x))
    return(out)

مثال(1): سوف نقوم بتصوير مجموعة بيانات تحوي مسميات عربية كما يلي:

In:
import matplotlib.pyplot as plt
labels = f('متزوج'), f('أعزب')
sizes = [80, 14]
colors = ['gold', 'lightcoral']
explode = (0.2, 0)

plt.pie(sizes, explode=explode, labels=labels, colors=colors,
        autopct='%1.1f%%', shadow=True)
plt.title(f('الحالة الإجتماعية للعملاء'))
 
plt.axis('equal')
plt.show()

والذي يعطي النتيجة التالية:

ملاحظة: يمكن تحسين الخط من خلال تحميل الخط majalla ثم استخدام الكود التالي:

In:
import os
from matplotlib import font_manager as fm, rcParams
fpath = os.path.join(rcParams["datapath"], "C:\\Desktop\\majalla.ttf")
prop = fm.FontProperties(fname=fpath,size=20)

حيث يتم تغيير موقع الخط في الكود اعلاه (الموضح بالأزرق) ليتناسب مع موقع الخط على جهازك. ثم بعد ذلك نستخدم الكود:

In:
labels = f('متزوج'), f('أعزب')
sizes = [80, 14]
colors = ['gold', 'lightcoral']
explode = (0.2, 0)

plt.pie(sizes, explode=explode, labels=labels, colors=colors,
        autopct='%1.1f%%', shadow=True,textprops={'fontproperties':prop})
plt.title(f('الحالة الإجتماعية للعملاء'),fontproperties=prop)
 
plt.axis('equal')
plt.show()

والذي يعطي النتيجة:

مثال(2): نفرض أن لدينا البيانات mydata والتي تحوي بيانات عربية وبالتالي لتمثيلها سوف يتم اتباع الخطوات التالية:

1. استيراد البيانات كما يلي:

In:
import pandas as pd
mydata = pd.read_csv("C:\\Desktop\\mydata.csv")
mydata
Out:
name mark
أحمد	3
محمد	5
خالد	6
علي	4
عبدالله	9

2. تطبيق الدالة المعرفة f على عمود الأسم (name) كما يلي:

In:
mydata['name']=mydata['name'].apply(f)

3. استخدام الكود التالي:

In:
mydata.plot.bar(x='name',y='mark',legend=False)
plt.ylabel(f('الدرجة من 10'),fontproperties=prop)
plt.xlabel(f('الطلاب'),fontproperties=prop)
plt.xticks(fontproperties=prop)
plt.show()

والذي يعطي النتيجة:

في هذا المقال سوف نستعرض كيفية تنفيذ التصوير ثلاثي الأبعاد للبيانات والدوال بإستخدام لغة البرمجة بايثون. في البداية سوف نقوم بتثبيت وتفعيل بعض الحزم المطلوبة وهي:

In:
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

الآن سوف نستعرض بعض طرق التصوير ثلاثي الأبعاد للبيانات والدوال كما يلي:

اولاً: الأعمدة البيانية ثلاثية الأبعاد

ويمكن الحصول على ذلك من خلال الكود التالي:

In:
import numpy as np
import random 

fig = plt.figure(figsize=(10,10))
ax = plt.axes(projection="3d")

x = np.random.randint(1,10,7)
y = np.random.randint(1,10,7)
z = np.zeros(7)
dx = np.ones(7)
dy = np.ones(7)
dz = np.random.randint(1,10,7)

ax.bar3d(x, y, z, dx, dy, dz)
ax.set_xlabel('x',)
ax.set_ylabel('y')
ax.set_zlabel('z');
plt.show()

والذي يعطي الشكل التالي:

ملاحظة: z, y ,x تمثل إحداثيات نقطة ربط الأعمدة البيانية و dz, dy, dx تمثل عرض الأعمدة وعمقها وارتفاعها على التوالي.

ثانياً: التصوير ثلاثي الأبعاد للدوال

للتصوير ثلاثي الأبعاد للدوال نتبع الخطوات التالية:

1. تعريف الدالة، مثلاً:

In:
def f(x, y):
    return x*y

2. تحديد البيانات او القيم التي سوف يتم تصوير الدالة عندها، مثلاً:

In:
x = np.linspace(-5, 5, 30)
y = np.linspace(-5, 5, 30)
x, y = np.meshgrid(x, y)
z = f(x, y)

3. تصوير الدالة باستخدام الكود التالي:

In:
fig = plt.figure(figsize=(10,10))
ax = plt.axes(projection='3d')
ax.plot_surface(x, y, z, rstride=1, cstride=1,
                cmap='viridis', edgecolor='none')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
plt.show()

والذي يعطي الشكل التالي:

مثلاً، باستخدام الطريقة اعلاه يمكن تصوير التوزيع الطبيعي متعدد المتغيرات ( multivariate Gaussian distribution) باستخدام الكود التالي:

In:
from scipy.stats import multivariate_normal

mu = [0, 0]
covariance = [[1, 0], [0, 1]]

x = np.linspace(-3,3,100)
y = np.linspace(-3,3,100)
x, y = np.meshgrid(x,y)
xy = np.empty((100,100,2))
xy[:, :, 0] = x; xy[:, :, 1] = y
mvn = multivariate_normal(mu, covariance)
z=mvn.pdf(xy)

fig = plt.figure(figsize=(10,10))
ax = fig.gca(projection='3d')
ax.plot_surface(x, y,z,cmap='viridis',linewidth=0)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
plt.show()

والذي يعطي الشكل التالي:

لكتابة كود في لغة البرمجة بايثون يعتمد على شرط او شروط معينه هناك عدد من الدوال والعبارات البرمجية التي يمكن استخدامها. فمثلاً يمكن إستخدم الدالة (if) والتي يمكن أن توظف كما في الكود التالي:

In:
x=3
if x<5: 
    print ("the number is less than 5")
Out:
the number is less than 5

كذلك يمكن إستخدام أكثر من شرط كا يلي:

In:
x=-2
if x<5 and x <0: 
    print ("the number is less than 5 and it is negative")
Out:
the number is less than 5 and it is negative

حيث يمكن إستخدام عمليات المقارنة و العمليات المنطقية التي تم توضيحها في مقدمة في البايثون Python لكتابة الشرط او الشروط المناسبة.

كذلك يمكن إستخدام الدالة (else) للتعبير عن نتيجة عدم تحقق الشرط كما يلي:

In:
x=6
if x<5:
    print ("the number is less than 5")
else:
    print ("the number is greater than 5")
Out:
the number is greater than 5

عندما يكون لدينا أكثر من إحتمالين للشرط المطلوب، يمكن إستخدام الدالة (elif) لإضافة شرط آخر أو أكثر كما يلي:

In:
x=5
if x<5:
    print ("the number is less than 5")
elif x==5:
    print ("the number is equal to 5")
else:
    print ("the number is greater than 5")
Out:    
the number is equal to 5

كما يمكن استخدام الشروط المضمنة كما يلي:

In:
x=7
if x<5:
    print ("the number is less than 5")
else:
    if x==5:
        print ("the number is equal to 5")
    else:
        print ("the number is greater than 5")
Out:        
the number is greater than 5

عند كتابة كود في برنامج بايثون Python فأنك قد تحتاج لكتابة دالة خاصة بك تقوم بحساب بعض العمليات وتعطيك نتائج محددة تحتاجها، وهذه الدالة قد تجنبك تكرار أجزاء طويلة من الكود. الشكل العام للدالة المعرفة في برنامج بايثون يعطى كما يلي:

فمثلاً، لكتابة دالة قوم بحساب تربيع عدد مدخل، نكتب هذه الدالة:

In:
def Sq(x):
    out=x*x
    return (out)

والتي يتم إستخدامها كما يلي:

In:
Sq(4)
Out:
16
In:
Sq(12)
Out:
144

كما يمكن كتابة دالة لحساب الجذر التربيعي للعدد المدخل كما يلي:

In:
def Sq_R(x):
    if x > 0: out=x**0.5
    else: out="x is less than zero"
    return (out)

Sq_R(9)
Out:
3.0
In:
Sq_R(-3)
Out:
'x is less than zero'

المتغير او البارامتر x يمكن أن يكون متجه يحوي عدة قيم. فمثلاً:

In:
def Sum(x):
    out=sum(x)
    return (out)

x=(2,3,5,4)
Sum(x)
Out:
14

ملاحظات هامة:

1. يمكن كتابة الدالة التالية:

In:
def Twice(x):
   return x * 2

باستخدم الدالة lambda كمايلي:

In:
Twice = lambda x: x * 2
Twice(3)

ونستخدم هذه الطريقة غالباً عندما نحتاح دالة بدون اسم وتكون مضمنة داخل دالة أخرى، مثلاً:

In:
a = [3, 5, 6]
b = list(map(lambda x: x * 2 , a))
b
Out:
[6, 10, 12]

2. لتجنب التعارض مع الدوال الإفتراضية في البرنامج، إستخدم الحروف الكبيرة عند كتابة أسم الدالة الخاصة بك.

تستخدم حلقات التكرار (Loops) بشكل شايع في اكواد برنامج بايثون، لذلك فإن معرفتها وفهما بشكل جيد يساعد في بناء الكود بشكل صحيح. تأخد حلقات التكرار في بايثون عدة أشكال سوف نوضحها في هذا المقال.

اولاً: حلقات التكرار بإستخدام  for .

لبناء حلقة تكرار تستخدم مجموعة عشوائية من الأرقام، نستخدم الكود التالي:

In: 
for i in [1, 4, 5]:
    print (i)
Out:
1
4
5

او

In:
for i in (1, 4, 5):
    print (i)
Out:
1
4
5

كذلك يمكن بناء حلقة تكرار تستخدم  سلسلة من الأرقام كما يلي:

In:
for i in range(1,4):
    print (i)
Out:
1
2
3

ايضاً يمكن بناء حلقة تكرار تستخدم  مجموعة من الكلمات، باستخدام الكود التالي:

In:
for i in {'one', 'two', 'three'}:
    print (i)
Out:
one
three
two

لإستخدام الكلمات مرتبه، يمكن استخدام الكود:

In:
for i in {'one':1, 'two':2, 'three':3}:
    print (i)
Out:
one
two
three

كذلك يمكن بناء حلقة تكرار كما يلي:

In:
for i in "125":
    print (i)
Out:
1
2
5

او

In:
for i in "Aziz":
    print (i)
Out:
A
z
i
z

كذلك يمكن بناء حلقة تكرار لقراءة أسطر ملف نصي (مثلاً: myfile ) كما يلي:

In:
for line in open("myfile.txt"):
    print (line)
Out:
I am Aziz

I am a data scientist

I am coding with Python

ملاحظة: لتحديد دليل العمل (موقع الملف على جهازك)، يمكن استخدام:

In:
import os
os.chdir('Desktop')

ثانياً: حلقات التكرار بإستخدام while

يمكن استخدام while لبناء حلقة تكرار كما يلي:

In:
i=0
x=range(2,10)
while x[i]<5:
    print(x[i])
    i=i+1
Out:
2
3
4

يمكن إستخدام بعض الدوال داخل حلقات التكرار وهي:

كما هو موضح في الحالات التالية:

اولاً: استخدام  break

In:
for x in (2,-3,4,5):
    if x < 0:
        break
    print(x)
Out:
2

ثانياً: استخدام  continue

In:
for x in (2,-3,4,5):
    if x < 0:
        continue
    print(x)
Out:
2
4
5

ثالثاً: استخدام  pass

In:
for x in (2,-3,4,5):
    if x < 0:
        pass
        x=-x
    print(x)
Out:
2
3
4
5

نلاحظ انه تم تنفيذ الخطوه ولكن غيرنا إشارة العدد.

عندما نتعامل مع البيانات نحتاج في كثير من الأحيان الى اجراء بعض العمليات او تطبيق بعض الدوال على الصفوف او الأعمدة. في هذا المقال سوف نتعرف على كيفية عمل ذلك من خلال استخدام الدالة apply. في البداية سوف نقوم استيراد المكتبات التي سوف نحتاجها وهي:

In:
import pandas as pd
import numpy as np

كذلك نفرض ان لدينا البيانات التالية:

In:
df = pd.DataFrame([{'a': 3, 'b': 1}, {'a': 2, 'b': 4}, {'a': 0, 'b': 6}])
df
Out:
   a  b
0  3  1
1  2  4
2  0  6

بعد ذلك سوف نقوم باستخدام الدالة apply والتي تأخذ الشكل التالي:
df.apply(func, axis, args, ...)
حيث أن:

وهناك عدة أمثلة على كيفية استخدامها يمكن تلخيصها كما يلي:

1. تطبيق دالة على كامل عناصر الصفوف او الأعمدة. مثل جمع العناصر على مستوى الصفوف:

In:
new_df = df.apply(sum, axis=1)
new_df
Out:
Out:
0    4
1    6
2    6

2. تطبيق دالة على عناصر الصفوف والأعمدة بشكل منفصل. مثل أخذ الجذر التربعي:

In:
new_df = df.apply(np.sqrt)
new_df
Out:
          a        b
0  1.732051  1.00000
1  1.414214  2.00000
2  0.000000  2.44949

ويمكن تطبيقها على عمود محدد كما يلي:

In:
df['a'] = df['a'].apply(np.sqrt)
df
Out:
         a  b
0  1.732051  1
1  1.414214  4
2  0.000000  6

او صف محدد كما يلي:

In:
df.iloc[2] = df.iloc[2].apply(np.sqrt)
df
Out:
     a        b
0  3.0  1.00000
1  2.0  4.00000
2  0.0  2.44949

3. يمكن استخدام الدالة apply مع اي دالة معرفة، مثل دالة حساب التربيع:

In:
def Squared (x):
    out=x**2
    return(out)

new_df = df.apply(Squared)
new_df
Out:
     a     b
0  9.0   1.0
1  4.0  16.0
2  0.0   6.0

او مع دالة lambda المعرفة كما يلي:

In:
new_df = df.apply(lambda x: x**2, axis=0 )
new_df
Out:
     a     b
0  9.0   1.0
1  4.0  16.0
2  0.0   6.0

4. استخدام دالة apply مع دالة ذات متغيرات، مثل:

In:
def add_number(x,a):
    return x+a

new_df = df.apply(add_number,args=[2]) 
new_df
Out:
   a  b
0  5  3
1  4  6
2  2  8

لتصوير الارتباط (correlation) بين المتغيرات باستخدام بايثون، سوف نستخدم مكتبة: seaborn وهي مكتبة متخصصة في تصوير البيانات في بايثون وتعمل بالاعتماد على المكتبة المعروفة matplotlib. تتميز مكتبة: seaborn  بقدرتها على انتاج رسوم بيانية جذابة ومبتكرة. في البداية سوف نستخدم البيانات: mydata. حيث يمكن استيرادها بعد تحميلها كما يلي:

In:
import pandas as pd
mydata = pd.read_csv('mydata.csv',sep=',')

يمكن تصوير الارتباط بين المتغيرات بعدة طرق منها:

اولاً: تصوير مصفوفة الارتباط (correlation matrix)

ويمكن ذلك من خلال الكود التالي:

In:
import seaborn as sns
import matplotlib.pyplot as plt

corr_coef = mydata.corr(method= 'pearson').round(2)
f, ax = plt.subplots(figsize=(5, 5))

C=sns.diverging_palette(10, 150, as_cmap=True)

sns.heatmap(corr_coef, cmap=C,vmin=-1, vmax=1,
            center=0,annot=True,cbar_kws={"shrink": .7})

والذي يعطي الشكل التالي:

الدالة ()corr يمكن أن تأخد اساليب مختلفة من الإرتباط وهي:

method =’pearson’ or ‘kendall’ or ‘spearman’

حسب نوع البيانات. ويمكن التعديل على الكود السابق كما يلي:

In:
import numpy as np

corr_coef = mydata.corr(method= 'pearson').round(2)
f, ax = plt.subplots(figsize=(5, 5))

M = np.zeros_like(corr_coef, dtype=np.bool)
M[np.triu_indices_from(M)] = True

C=sns.diverging_palette(10, 150, as_cmap=True)

sns.heatmap(corr_coef,mask=M, cmap=C, vmin=-1, vmax=1,
            center=0,annot=True,cbar_kws={"shrink": .7})

وبالتالي يعطي الشكل التالي:

ثانياً: بواسطة correlogram

ويمكن ذلك من خلال الدالة التالية:

In:
sns.pairplot(mydata)

والتي تعطي الرسوم البيانية التالية:

ويمكن التعديل على الدالة السابقة كما يلي:

In:
sns.pairplot(mydata, diag_kind="kde")

وبالتالي تعطي الرسوم البيانية التالية:

يمكن مقارنة المتوسط (Mean) لمجموعتين او عينتين $x$ و $y$ من البيانات المستقلة (independent) بإستخدام اختبار t-test والذي يعتمد على الفرض (assumption) بأن هذه البيانات تمثل مجتمع يتبع التوزيع الطبيعي (normal distribution). حيث يكتب إختبار الفرض الإحصائي (Hypothesis test) كما يلي:

\begin{align*}
H_{0}:\mu_{x}=\mu_{y} \\
H_{1}:\mu_{x}\neq \mu_{y}
\end{align*}

والذي يفضل كتابته كما يلي:

\begin{align*}
H_{0}:\mu_{x}-\mu_{y}=0 \\
H_{1}:\mu_{x}- \mu_{y}\neq0
\end{align*}

نفرض أن لدينا البيانات mydata، حيث سوف نقوم باختبار ما إذا كان هناك اختلاف هام في المتوسط بين حجم مبيعات المتجر A والمتجر B وذلك باتباع الخطوات التالية:

اولا:استيراد البيانات

In:
import pandas as pd
mydata = pd.read_csv('mydata.csv',sep=',')
shopA=mydata['shopA']
shopB=mydata['shopB']

ثانيا: استخدام box plot للتأكد من عدم وجود قيم متطرفة (outliers)

In:
import matplotlib.pyplot as plt
mydata.plot(kind='box')
plt.show()

ثالثاً: التأكد من أن البيانات تتبع التوزيع الطبيعي (normal distribution)، من خلال:

• استخدام Q-Q plot:

In:
from scipy import stats
plt.subplot(1, 2, 1)
stats.probplot(mydata['shopA'], plot= plt)
plt.title('shopA')
plt.subplot(1, 2, 2)
stats.probplot(mydata['shopB'], plot= plt)
plt.title('shopB')
plt.show()

• استخدام Shapiro-Wilk test، حيث أن:

فرض العدم $H_{0}$: البيانات تتبع التوزيع الطبيعي

والفرض البديل $H_{1}$: البيانات لا تتبع التوزيع الطبيعي

In:
from scipy.stats import shapiro
for r in (shopA,shopB):
    stat, p_value = shapiro(r)
    print(r.name,"stat:",round(stat, 4), "P-value:", round(p_value, 4))
Out:
shopA stat: 0.9801 P-value: 0.431
shopB stat: 0.9928 P-value: 0.9788

لكل المجموعتين نلاحظ أن P-value اكبر من 0.05 وبالتالي يمكن القول أن البيانات تتبع التوزيع الطبيعي.

رابعاً: تحديد ما اذا كان التباين (variance) بين مجموعتي البيانات متساوي باستخدام Levene’s test، حيث أن:

فرض العدم $H_{0}$: التباين لمجموعتي البيانات متساوي.

والفرض البديل $H_{1}$: التباين لمجموعتي البيانات غير متساوي.

In:
from scipy.stats import levene
stat, p_value = levene(shopA,shopB)
print("stat:",round(stat, 4), "P-value:", round(p_value, 4))
Out:
stat: 0.3695 P-value: 0.5444

نلاحظ أن P-value اكبر من 0.05 وبالتالي يمكن القول أن مجموعتي البيانات لها نفس التباين.

خامساً: تحديد ما اذا كان هناك إرتباط (correlation) بين مجموعتي البيانات باستخدام scatter plot، كما يلي:

In:
import seaborn as sns
sns.scatterplot(shopA, shopB)
plt.show()

سادساً: تطبيق t-test، حيث أن:

فرض العدم $H_{0}$: متوسطي مجموعتي البيانات متساوية.

والفرض البديل $H_{1}$: متوسطي مجموعتي البيانات غير متساوية.

ونظراً لتحقق الفروض اعلاه سوف نستخدم t-test للعينات المستقلة ذات التباين المتساوي:

In:
from scipy.stats import ttest_ind
stat, p_value = ttest_ind(shopA, shopB)
print("stat:",round(stat, 4), "P-value:", round(p_value, 4))
Out:
stat: 1.1574 P-value: 0.2494

نلاحظ أن P-value اكبر من 0.05 وبالتالي يمكن القول أنه ليس هناك اختلاف بين متوسطي المجموعتين.

ملاحظات هامة:

• إذا لم يتحقق فرض تساوي التباين للمجوعتين نستخدم Welch’s t-test:

stat, p_value = ttest_ind(shopA, shopB,equal_var=False)
print("stat:",round(stat, 4), "P-value:", round(p_value, 4))

• إذا لم يتحقق فرض استقلال للمجوعتين نستخدم:

from scipy.stats import ttest_rel
stat, p_value = ttest_rel(shopA, shopB)
print("stat:",round(stat, 4), "P-value:", round(p_value, 4))

الأنحدار الخطي (linear regression) هو أسلوب إحصائي يهدف لإيجاد علاقة خطية بين المتغير التابع (dependent variable) والمتغيرات المستقلة (independent variables)، كذلك يهدف الى التنبؤ (prediction) بقيم المتغير التابع. ويمكن تعريف الإنحدار الخطي رياضياً كما يلي:

\[
y=\alpha+\beta_1 x_1+\beta_2 x_2+…+\beta_p x_p+\epsilon
\]

حيث يسمى $y$ المتغير التابع (dependent variable) او متغير الإستجابة (response variable) او متغير الناتج (outcome variable)، كذلك تسمى $x_1, x_2,…, x_p$ المتغيرات المستقلة (independent variables) او المتغيرات التفسيرية (explanatory variables) او متغيرات التنبؤ (predictor variables).

تُعرف البواقي (Residuals) بأنها الفرق بين القيمة الملاحظة (الفعلية) للمتغير التابع وقيمة المتغير التابع التي يتم التنبؤ بها بإستخدام خط الانحدار.

تعطى فروض الإنحدار الخطي (assumptions of linear regression) كما في الشكل ادناه:

الآن سوف نتناول تطبيق الإنحدار الخطي (Linear regression) في برنامج بايثون (Python). نقوم بتحميل بعض الحزم (packages) التي نحتاجها وهي:

In:
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn import datasets
import statsmodels.formula.api as smf
from statsmodels.graphics.gofplots import ProbPlot

كذلك نقوم بتحميل البيانات التي سوف نستخدمها وهي diabetes dataset  تحوي 442 مشاهدة و 10 متغيرات وهي العمر ، الجنس ، مؤشر كتلة الجسم ، متوسط ضغط الدم ، وستة قياسات لمصلية الدم  وهي متوفرة من خلال حزمة sklearn:

In:
diabetes = datasets.load_diabetes()
x = np.concatenate(diabetes.data[:, np.newaxis, 2])
y = diabetes.target
mydata = pd.DataFrame({'x':x, 'y':y})

نلاحظ أن تم إختيار متغيرين تمت تسميتها x و y وتم تخزينا في بيانات جديدة mydata لإستخدامها في شرح هذا الموضوع، مع ملاحظة أنه يمكن استخدام جميع البيانات. اولاً: نرسم شكل الإنتشار والذي يمثل العلاقة بين المتغيرين باستخدام الكود:

In:
plt.scatter(x, y)
plt.xlabel("x")
plt.ylabel("y")
plt.show()

والذي يعطي الشكل التالي:

ثم نقوم بنمذجة هذه العلاقة باستخدام الإنحدار الخطي كما يلي:

In:
model_f='y~x'
model = smf.ols(formula=model_f, data=mydata)
model_fit = model.fit()

حيث يمكن تصوير هذا النموذج الخطي باستخدام الكود:

In:
fitted_values=model_fit.fittedvalues
plt.scatter(x, y)
plt.plot(x, fitted_values, c='r')
plt.xlabel("x")
plt.ylabel("y")
plt.show()

والذي يعطي النتيجة التالية:

كما يمكن عرض ملخص نتائج هذا النموذج باستخدام الدالة:

In:
print (model_fit.summary())
Out:
                            OLS Regression Results                            
==============================================================================
Dep. Variable:                      y   R-squared:                       0.344
Model:                            OLS   Adj. R-squared:                  0.342
Method:                 Least Squares   F-statistic:                     230.7
Date:                Sat, 27 Oct 2018   Prob (F-statistic):           3.47e-42
Time:                        11:39:03   Log-Likelihood:                -2454.0
No. Observations:                 442   AIC:                             4912.
Df Residuals:                     440   BIC:                             4920.
Df Model:                           1                                         
Covariance Type:            nonrobust                                         
==============================================================================
                 coef    std err          t      P>|t|      [0.025      0.975]
------------------------------------------------------------------------------
Intercept    152.1335      2.974     51.162      0.000     146.289     157.978
x            949.4353     62.515     15.187      0.000     826.570    1072.301
==============================================================================
Omnibus:                       11.674   Durbin-Watson:                   1.848
Prob(Omnibus):                  0.003   Jarque-Bera (JB):                7.310
Skew:                           0.156   Prob(JB):                       0.0259
Kurtosis:                       2.453   Cond. No.                         21.0
==============================================================================

كذلك يمكن الحصول على الاشكال اللازمة للتأكد من فروض النموذج الخطي (Diagnostic Plots) وأهمها:

اولاً: QQ-plot والذي يستخدم للتأكد من أن البواقي (residuals) تتبع التوزيع الطبيعي (Normal distribution). والذي يمكن الحصول عليه باستخدام الكود:

In:
residuals = model_fit.resid
studentized_residuals = model_fit.get_influence().resid_studentized_internal

QQ = ProbPlot(studentized_residuals)
plot=QQ.qqplot(line='45', alpha=0.5, color='#4C72B0', lw=1,ylabel='Standardized Residuals')


plt.title('Normal Q-Q')
plt.xlabel('Theoretical Quantiles')
plt.ylabel('Standardized Residuals')

top_abs_studentized_residuals = np.flip(np.argsort(np.abs(studentized_residuals)), 0)[:3]
for r, i in enumerate(top_abs_studentized_residuals):
    plt.annotate(i, xy=(np.flip(QQ.theoretical_quantiles, 0)[r],studentized_residuals[i]))

والذي يعطي الشكل:

ثانياً: Residuals vs Fitted values وهو مفيد للتأكد من فرض الخطية وتجانس التباين ( the assumption of linearity and homoscedasticity)، حيث يأخذ شكل إنتشار عشوائي حول الصفر والذي يمثل تقريباً منتصف المحور العامودي الذي يمثل البواقي الموجبة والسالبة. كذلك يجب أن لايكون هناك اي مشاهدة خارج الإنشار بشكل واضح (شاذة او متطرفة). والذي يمكن الحصول عليه باستخدام الكود:

In:
plot = sns.residplot(fitted_values, 'y', data=mydata, 
                          lowess=True, 
                          scatter_kws={'alpha': 0.5}, 
                          line_kws={'color': 'red', 'lw': 1, 'alpha': 0.8})

plt.title('Residuals vs Fitted values')
plt.xlabel('Fitted values')
plt.ylabel('Residuals')

abs_residuals=np.abs(residuals)
top_abs_residuals = abs_residuals.sort_values(ascending=False)[:3]

for i in top_abs_residuals.index:
    plt.annotate(i, xy=(fitted_values[i], residuals[i]))

والذي يعطي الشكل:

ثالثاً: Scale-Location وهو مفيد للتأكد من فرض تجانس التباين ( the assumption of homoscedasticity)، حيث يأخذ شكل إنتشار عشوائي ولا يأخد شكل منتظم متزايد او متناقص. والذي يمكن الحصول عليه باستخدام الكود:

In:
abs_sqrt_studentized_residuals = np.sqrt(np.abs(studentized_residuals))
plt.scatter(fitted_values, abs_sqrt_studentized_residuals, alpha=0.5)
sns.regplot(fitted_values, abs_sqrt_studentized_residuals, 
            scatter=False, 
            ci=False, 
            lowess=True,
            line_kws={'color': 'red', 'lw': 1, 'alpha': 0.8})

plt.title('Scale-Location')
plt.xlabel('Fitted values')
plt.ylabel('$\sqrt{|StandardizedResiduals|}$')


 
top_abs_sqrt_studentized_residuals= np.flip(np.argsort(abs_sqrt_studentized_residuals), 0)[:3]
for i in top_abs_sqrt_studentized_residuals:
    plt.annotate(i, xy=(fitted_values[i], abs_sqrt_studentized_residuals[i]))

والذي يعطي الشكل التالي:

رابعاً: Residuals vs Leverage والذي يستخدم لقياس تأثير كل مشاهدة على معاملات (coefficients) الانحدار الإنحدار الخطي. والذي يمكن الحصول عليه باستخدام الكود:

In:
model_leverage = model_fit.get_influence().hat_matrix_diag
cooks_distance = model_fit.get_influence().cooks_distance[0]
plt.scatter(model_leverage, studentized_residuals, alpha=0.5)
sns.regplot(model_leverage, studentized_residuals, 
            scatter=False, 
            ci=False, 
            lowess=True,
            line_kws={'color': 'red', 'lw': 1, 'alpha': 0.8})

plt.xlim(0,0.035)
plt.title('Residuals vs Leverage')
plt.xlabel('Leverage')
plt.ylabel('Standardized Residuals')

top_leverage= np.flip(np.argsort(cooks_distance), 0)[:3]
for i in top_leverage:
    plt.annotate(i, xy=(model_leverage[i],studentized_residuals[i]))

والذي يعطي الشكل:

كما يمكن إضافة حدود Cook’s distance بإضافة الاسطر التالية للكود السابق:

In:
plt.ylim(-3,8)
r = np.linspace(0.001, 0.035, 50)
p = len(model_fit.params)
d = np.sqrt((0.5 * p * (1 - r)) / r)
plt.plot(r, d, label='Cook\'s distance', lw=1, ls='--', color='red')
plt.legend(loc='upper right')

ليعطي الشكل التالي:

الانحدار اللوجستي (logistic regression) هو أسلوب إحصائي يستخدم لوصف العلاقة بين متغير تابع (dependent variable) ثنائي (binary) ومتغير مستقل (independent variable) واحد او أكثر وفق الصيغة التالية:

\[
logit(p)=\alpha+\beta X
\]

حيث

\[
logit(p)=\ln{\left(\frac{p}{1-p}\right)}
\]

وكذلك $$p=p(y=1|X)$$.

ملاحظة: في تعلم الآلة، يعرف المتغير التابع (dependent variable) بالمتغير الهدف (target variable). كذلك تعرف المتغيرات المستقلة (independent variables) بمتغيرات التنبؤ (predictor variables) او الخصائص (features).

وهناك عدد من الفروض (assumptions) الهامة التي ينبغي التنبه لها عند استخدام الانحدار اللوجستي وهي:

الآن سوف نوضح كيف يمكن تطبيق نموذج الانحدار اللوجستي على البيانات: Breast Cancer Wisconsin Data Set وذلك باستخدام لغة البرمجة بايثون. المزيد من التفاصيل حول هذه البيانات على الرابط. للقيام بذلك سوف نتبع الخطوات التالية:

1. تحميل البيانات:

In:
import pandas as pd 
wdbc_data = pd.read_csv('wdbc.csv',sep=',')
wdbc_data.head()
Out:
         id diagnosis  radius_mean  ...  concave points_worst  symmetry_worst  fractal_dimension_worst
0    842302         M        17.99  ...                0.2654          0.4601                  0.11890
1    842517         M        20.57  ...                0.1860          0.2750                  0.08902
2  84300903         M        19.69  ...                0.2430          0.3613                  0.08758
3  84348301         M        11.42  ...                0.2575          0.6638                  0.17300
4  84358402         M        20.29  ...                0.1625          0.2364                  0.07678

في هذه الحالة سوف يكون المتغير التابع (المتغير الهدف) هو diagnosis وهو ثنائي كما يتضح من التالي:

In:
wdbc_data['diagnosis'].value_counts()
Out:
B    357
M    212
Name: diagnosis, dtype: int64

حيث يمثل هذا المتغير تشخيص الخلايا السرطانية الى خبيثة (M) او حميدة (B)، وجميع المتغيرات المتبقية هي متغيرات مستقلة (خصائص). سوف يتم تخزين المتغير التابع diagnosis في المتغير y بعد استبدال M بـ 1 و B بـ 0، كذلك سوف يتم تخزين المتغيرات المستقلة في المصفوفة X كما يلي:

In:
wdbc_data['diagnosis']=wdbc_data['diagnosis'].replace('M',1 )
wdbc_data['diagnosis']=wdbc_data['diagnosis'].replace('B', 0)
y = wdbc_data['diagnosis']
X = wdbc_data.iloc[0:, 2:32]

2. تقسيم البيانات الى مجموعة تدريب (train) ومجموعة اختبار (test):

سوف نقوم في هذه الخطوة بتقسيم البيانات الى مجموعتين واحدة لتدريب النموذج والاخرى لاختباره لاحقاً، وذلك باستخدام الكود:

In:
from sklearn.model_selection import train_test_split
y_train,y_test,X_train,X_test = train_test_split(y,X,test_size = .2) 

3. تطبيق نموذج الانحدار اللوجستي:

في هذه الخطوة سوف نقوم بتطبيق النموذج على مجموعة التدريب من خلال الدوال التالية:

In:
from sklearn.linear_model import LogisticRegression
logist_model=LogisticRegression()
logist_model.fit(X_train,y_train)

يمكن الحصول على على قيم المعاملات (coefficients) بإستخدام الدالة:

In:
logist_model.coef_

حيث يجب تحديد المتغيرات المستقلة الهامة التي يجب ان تكون في النموذج واستبعاد الأخرى للوصول لأفضل نموذج يجب تطبيقه، كذلك من المهم التأكد من تحقق الفروض الخاصة بالانحدار اللوجستي، وكذلك التأكد من عدم وجود خطية متعددة (multicollinearity) او قيم متطرفة (outliers).

 4. التحقق من صحة النتائج (validation):

في هذه الخطوة سوف نقوم باستخدام مجموعة الاختبار للتحقق من دقة النموذج المستخدم وذلك من خلال:

• مصفوفة الخطأ (confiusion matrix):

حيث يمكن استخدام الكود:

In:
from sklearn import metrics
from mlxtend.plotting import plot_confusion_matrix
y_pred=logist_model.predict(X_test)
cm = metrics.confusion_matrix(y_test, y_pred)
plot_confusion_matrix(cm)

والذي يعطي النتيجة التالية:

• معدل الدقة (Accuracy) والإحكام (Precision) :

وذلك من خلال استخدام الدوال التالية:

In:
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
print("Precision:",metrics.precision_score(y_test, y_pred))
Out:
Accuracy: 0.96
Precision: 0.97

في هذا المقال سوف نتعرف بالخطوات كيف يمكن صنع الأعمدة البيانية المتحركة (Animated Race Bar) باستخدام لغة البرمجة بايثون. سوف نستخدم البيانات covid_data ثم نتبع الخطوات التالية:

اولاً: تحديد دليل العمل (working directory) كما يلي:

In:
import os
os.chdir('*****')

ثانياً: استيراد البيانات باستخدام الكود:

In:
import pandas as pd
covid_data = pd.read_csv("covid_data.csv")

ثالثاً: تحميل FFmpeg من خلال الضغط هنا ثم بعد حفظ الملف على جهازك استخدم الكود التالي لتحديد موقع الملف ffmpeg.exe :

In:
import matplotlib as plt 
plt.rcParams['animation.ffmpeg_path'] = r'C:\FFmpeg\bin\ffmpeg.exe'

رابعاً: تعويض القيم المفقودة (NA/NaN) بـ بصفر كما يلي:

In:
covid_data=covid_data.fillna(0)

خامساً: وضع التاريخ كـ index باستخدام الدالة:

In:
covid_data.set_index("date", inplace = True)

سادساً: تجميع (aggregating) البيانات على مستوى التاريخ باستخدام الكود:

In:
covid_data=covid_data.groupby(covid_data.index).sum()

سابعاً: صنع الأعمدة البيانية المتحركة (Animated Race Bar) باستخدام الدالة التالية:
bar_chart_race(df, filename, orientation, ...)
حيث تأخذ هذه الدالة عدة خيارات من أهمها:

وبالتالي يمكن استخدام الدالة كما يلي:

In:
import bar_chart_race as bcr
bcr.bar_chart_race(df=covid_data, filename='covid19_cases.mp4',title='Top 10 countries with the highest number of covid 19 cases',n_bars=10)

و سوف يتم حفظ الملف في الموقع الذي تم تحديده في الخطوة الأولى كما يلي:

يمكن إستيراد بيانات من تويتر بإستخدام لغة البرمجة بايثون من خلال الخطوات التالية:

اولاً: الحصول على حساب مطور 

https://developer.twitter.com/

ثانياً: اعداد تطبيق تويتر (Twitter App)، من خلال الرابط:

developer.twitter.com/en/apps

ثالثاً:  الحصول على مفاتيح ورموز (Keys and tokens) الوصول الى بيانات تويتر، كما في الشكل أدناه:

رابعاً: تحميل وتفعيل حزمة tweepy.

In:
import tweepy
import pandas as pd

خامساً: إعطاء بايثون صلاحية الوصول لبيانات تويتر

وذلك من خلال استحدام المفاتيح والرموز أعلاه كما يلي:

In:
access_token = "*****"
access_token_secret = "*****"
API_key = "*****"
API_secret_key = "*****"

حيث تستبدل ***** بالقيم الخاصة بها التي يمكن الحصول عليها من تويتر، ثم نستخدم الكود التالي:

In:
auth = tweepy.OAuthHandler(API_key, API_secret_key)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)

سادساً: استيراد البيانات

1. استيراد بيانات تاريخية وذلك من خلال:

• تغريدات التايم لاين لحسابك.

In:
timeline_tweets = api.home_timeline()

حيث يمكن الإطلاع على المتغيرات الموجودة في البيانات من خلال الكود:

In:
for key, value in timeline_tweets[0]._json.items():
    if type(value) is dict:
        print (key,list(value))
    else:
        print (key)

وبالتالي يمكن التعامل مع المتغيرات التي تحتاجها مثلاً كما يلي:

In:
variables_set = [[tweet.user.name, tweet.user.location,tweet.text,tweet.retweet_count] for tweet in timeline_tweets]
my_data = pd.DataFrame(data=variables_set, columns=['user', "location","tweets","retweet"])
my_data

• هاشتاق او كلمة مفتاحية.

In:
query = "السعودية"
language = "ar"
twitter_data = api.search(q=query, lang=language)
variables_set = [[tweet.user.screen_name, tweet.user.location,tweet.text,tweet.retweet_count] for tweet in twitter_data]
my_data = pd.DataFrame(data=variables_set, columns=['user', "location","tweets","retweet"])
my_data

حيث يتم إستبدال “السعودية” بأي هاشتاق أو كلمة مفتاحية.

• التايم لاين لحساب معين.

In:
name = "spagov"
tweetCount = 20
timeline_tweets = api.user_timeline(id=name, count=tweetCount)
variables_set = [[tweet.created_at,tweet.text,tweet.retweet_count] for tweet in timeline_tweets]
my_data = pd.DataFrame(data=variables_set, columns=['date and time', "tweets","retweet"])
my_data

حيث يتم إستبدال “spagov” بأي حساب آخر.

2. جمع بيانات تويتر لحظياً
يمكن جمع بيانات تويتر لحظياً وذلك من خلال تعريف الدالة أدناه اولاً:

In:
import sys
from tweepy import Stream
from tweepy.streaming import StreamListener

class Listener(StreamListener):
    def __init__(self, output_file=sys.stdout):
        super(Listener,self).__init__()
        self.output_file = output_file
    def on_status(self, status):
        print(status.text, file=self.output_file)
    def on_error(self, status_code):
        print(status_code)
        return False

حيث يمكن استبدال “status.text“ بأي متغير اخر من متغيرات بيانات تويتر. ثم بعد ذلك يمكن استخدام الكود التالي:

In:
output = open('twitter_data.txt', 'w')
listener = Listener(output_file=output)

stream = Stream(auth=api.auth, listener=listener)
try:
    print('Start')
    stream.filter(track=['السعودية'])
except KeyboardInterrupt:
    print("Stopped")
finally:
    stream.disconnect()
    output.close()

حيث يمكن استبدال كلمة “السعودية“ بأي كلمة مفتاحية أخرى او معرف مستخدم.

ملاحظة: يجب تحديد دليل العمل الذي سوف يحفظ عليه ملف البيانات، مثلاً استخدم:

In:
import os
os.chdir('Desktop')

لتصوير بيانات النصوص العربية في بايثون بإستخدام سحابة الكلمات (word cloud) يمكن إتباع الخطوات التالية:
اولاً: تفعيل الحزم (packages) اللازمة وهي:

In:
import pandas as pd
from wordcloud import WordCloud
from arabic_reshaper import arabic_reshaper
from bidi.algorithm import get_display

ملاحظة: لتحميل حزمة bidi.algorithm إستخدم الكود:

In:
python -m pip install python-bidi

ثانيا: في مجلد الحزمة wordcloud استبدل ملف الخط DroidSansMono بأي ملف خط عربي مع أبقاء نفس الأسم. مثلاً استخدم الخط.

ثالثاً: استخدام الأكواد الموضحة في المثال التالي:

سوف نستخدم بيانات تقييم الفنادق التي تم سحبها من TripAdvisor والمتوفرة على الرابط. بعد حفظ البيانات يمكن قراءتها في بايثون بإستخدام الكود:

In:
import os
os.chdir('****')
hotel_data = pd.read_csv('HTL.txt',sep=',')

حيث يتم إستبدال **** بدليل النظام الذي يحدد موقع البيانات. بعد ذلك نعمل تهيئة بسيطة للبيانات بواسطة الكود التالي:

In:
text = hotel_data['text']
text = [''.join(sentence) for sentence in text]
text = ''.join(text)

بعد ذلك يمكن تصوير البيانات النصية كما يلي:

In:
reshaped_text = arabic_reshaper.reshape(text)
arabic_text = get_display(reshaped_text)
wordcloud = WordCloud(width=700, height=300, background_color="white").generate(arabic_text)
wordcloud.to_image()

والذي يعطي الشكل التالي:

ملاحظة: هناك عدد من الخيارات الخاصة بالدالة WordCloud التي يمكنها التحكم في شكل سحابة الكلمات مثل:

في كثير من الأحيان نحتاج الى تقسيم السلاسل النصية (split strings) حتى يسهل التعامل معها ويتم تحضيرها وتهيئتها للتحليل، في هذا المقال سوف نستعرض بعض الدوال المناسبة لعمل ذلك في لغة البرمجة بايثون وطريقة عملها:

اولاً: تقسم سلسلة وفق محدد معين
str.split(sep, maxsplit)

حيث أن:

ويمكن توضيح ذلك من خلال المثال التالي:

In:
info= "محمد عبدالله العلي يسكن في شارع 22"
info.split(' ',1)
Out:
['محمد', 'عبدالله العلي يسكن في شارع 22']

كذلك يمكن عدم تحديد عدد التقسيمات:

In:
info.split(' ')
Out:
['محمد', 'عبدالله', 'العلي', 'يسكن', 'في', 'شارع', '22']

ويمكن استخدام اي من التقسيمات كما يلي:

In:
firstname=info.split(' ')[0]
firstname
Out:
'محمد'

ويمكن اختيار أي محدد، مثلا:

In:
address=info.split('يسكن في')[1]
address
Out:
' شارع 22'

ثانياً: تقسيم السلسلة وفق نمط محدد

re.split(pattern, string, maxsplit, ...)

حيث أن:

ويمكن توضيح ذلك من خلال المثال التالي:

In:
import re
re.split(r'(\d+)',info)
Out:
['محمد عبدالله العلي يسكن في شارع ', '22', '']

حيث تم استخدام النمط:

r'(\d+)’ 

والذي يمثل عدد صحيح

ثالثاً: ايجاد جميع تكرارات النمط في السلسلة

re.findall(pattern, string, ...)

حيث أن:

ويمكن توضيح ذلك من خلال المثال التالي:

In:
re.findall(r'[\d+]+.?[\d+]+',info) 
Out:
['22']

حيث تم استخدام النمط:

r'[\d+]+.?[\d+]+’

والذي يمثل عدد صحيح أو عشري

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

In:
text="@ffd هذا الفندق   غالي جداً ☹ ،   يكلفُ   حوالي 700$    لكل ليلة  https://www.google.com/..."

وبعد ذلك يمكن تلخيص خطوات معالجة البيانات النصية كما يلي:

1. حذف الروابط وذلك كما يلي:

In:
import re
text = re.sub(r'http\S+','',text)
text
Out:
'@ffd هذا الفندق   غالي جداً ☹ ،   يكلفُ   حوالي 700$    لكل ليلة  '

2. حذف المعرف (اسم المستخدم)، وذلك باستخدام الكود:

In:
text = re.sub(r'@\w+','',text)
text
Out:
' هذا الفندق   غالي جداً ☹ ،   يكلفُ   حوالي 700$    لكل ليلة  '

3. حذف علامات الترقيم والرموز، حيث يمكن حذف علامات ورموز محددة كما يلي:

In:
text = re.sub(r'[!"\$%&\'()*+,\-.\/:;=#@?\[\\\]^_`{|}~،ًُ]','',text)
text
Out:
' هذا الفندق   غالي جدا ☹    يكلف   حوالي 700    لكل ليلة  '

او جميع الرموز كما يلي:

In:
text = re.sub(r'[^\w\s]','',text)
text
Out:
' هذا الفندق   غالي جدا     يكلف   حوالي 700    لكل ليلة  '

4. حذف الأرقام، وذلك من خلال الكود التالي:

In:
text = re.sub(r'[\d+]+.?[\d+]+','', text)
text
Out:
' هذا الفندق   غالي جدا     يكلف   حوالي     لكل ليلة  '

5. حذف المسافات الزائدة بين الكلمات وذلك كما يلي:

In:
text = re.sub(r'\s+',' ',text)
text
Out:
' هذا الفندق غالي جدا يكلف حوالي لكل ليلة '

6. حذف الكلمات المستبعدة (stop words) باستخدام الكود:

In:
from nltk.corpus import stopwords
stop_words = stopwords.words('arabic')
text_list =[word for word in text.split() if word not in stop_words]
text= ' '.join(text_list)
text
Out:
'الفندق غالي جدا يكلف حوالي لكل ليلة'

او حذف اي كلمات أخرى كما يلي:

In:
extra_stop_words = 'لكل','ليلة','يكلف','حوالي'
text_list =[word for word in text.split() if word not in extra_stop_words]
text= ' '.join(text_list)
text
Out:
'الفندق غالي جدا'

7. ترميز (tokenizing) البيانات كما يلي:

In:
text = nltk.word_tokenize(text)
text
Out:
['الفندق', 'غالي', 'جدا']

معظم خوارزميات تعلم الالة لا يمكنها التعامل مع البيانات النصية. لذا يحب تحويل البيانات النصية الي بيانات رقمية وهو ما يعرف باستخراج الخصائص من النصوص (Feature extraction from text) حيث يتم تحويل النص الى مصفوفة من البيانات الرقمية. في هذا المقال سوف نستخدم دالتين من مكتبة scikit-learn وهي:

• CountVectorizer
• TfidfVectorizer

في البداية سوف نفرض أن لدينا البيانات التالية:

In:
text = ["الفندق جميل", 
        "عند وصولي الى الفندق لم اجد الغرفة مرتبة",
        "كان الفندق رائع وكذلك الغرفة نظيفة"]

اولاً: CountVectorizer

في البداية يتم عمل قاموس بكل كلمات الموجودة في البيانات النصية. بحيث لا تكون الكلمات متكررة ولو تكررت بعض الكلمات اكثر من مرة في البيانات تكون موجودة مرة واحدة في القاموس. يتم التعبير عن كل صف في البيانات بـ vector بحيث تكون جميع قيمة اصفار ما عدا الكلمات الموجودة في الصف تاخذ قيمة رقمية تمثل عدد مرات تكرارها. ويمكن أن يتم ذلك من خلال الخطوات التالية:

1. بناء قاموس الكلمات كما يلي:

In:
from sklearn.feature_extraction.text import CountVectorizer  
vectorizer = CountVectorizer() 
vectorizer.fit(text)
print(sorted(vectorizer.vocabulary_.items()))
Out:
[('اجد', 0), ('الغرفة', 1), ('الفندق', 2), ('الى', 3), ('جميل', 4), ('رائع', 5), ('عند', 6), ('كان', 7), ('لم', 8), ('مرتبة', 9), ('نظيفة', 10), ('وصولي', 11), ('وكذلك', 12)]

2. بناء المصفوفة الرقمية

In:
vector = vectorizer.transform(text) 
print(vector.toarray())
Out:
[[0 0 1 0 1 0 0 0 0 0 0 0 0]
 [1 1 1 1 0 0 1 0 1 1 0 1 0]
 [0 1 1 0 0 1 0 1 0 0 1 0 1]]

ثانياً: TfidfVectorizer

تقوم هذه الدلة بتحويل النص الى مصوفة رقمية تحوي أوزان (weights) باستخدام TFIDF وهو مقياس رقمي يعكس مدى أهمية كلمة لصف في البيانات من خلال اعطائها وزن يحسب من خلال الصيغة التالية:

\[TFIDF=TF(w,r)\times IDF(w)\]

حيث أن: $TF(w,r)$: عدد مرات تكرار الكلمة $w$ في الصف $r$.

كذلك:

\[IDF(w)=\log\left(\frac{1+n}{1+DF(w)}\right )+1\]

حيث أن: $DF(w)$: عدد الصفوف التي تحوي الكلمة $w$ و $n$ عدد الصفوف في البيانات. ويمكن أن يتم ذلك من خلال الخطوات التالية:

1. بناء قاموس الكلمات كما يلي:

In:
from sklearn.feature_extraction.text import TfidfVectorizer
vectorizer = TfidfVectorizer() 
vectorizer.fit(text) 
print(sorted(vectorizer.vocabulary_.items()))
Out:
[('اجد', 0), ('الغرفة', 1), ('الفندق', 2), ('الى', 3), ('جميل', 4), ('رائع', 5), ('عند', 6), ('كان', 7), ('لم', 8), ('مرتبة', 9), ('نظيفة', 10), ('وصولي', 11), ('وكذلك', 12)]

2. بناء مصفوفة الأوزان

In:
vector = vectorizer.transform(text) 
print(vector.toarray())
Out:
[[0.         0.         0.50854232 0.         0.861037   0.
  0.         0.         0.         0.         0.         0.
  0.        ]
 [0.37994462 0.28895767 0.22440141 0.37994462 0.         0.
  0.37994462 0.         0.37994462 0.37994462 0.         0.37994462
  0.        ]
 [0.         0.34261996 0.26607496 0.         0.         0.45050407
  0.         0.45050407 0.         0.         0.45050407 0.
  0.45050407]]

لتحليل الصور واستخدامها في نماذج تعلم الآلة، نحتاج لتحويل الصورة الى بيانات على شكل مصفوفة تحوي الارتفاع (Height)، العرض (Width)  والقناة (Channel). في هذا المقال سوف نستعرض كيفية استيراد الصور ومعالجتها وتحويها الى مصفوفة بيانات في بايثون، كذلك تحويلها من مصفوفة بيانات الى صورة وذلك كما يلي:

يمكن استيراد الصورة كمصفوفة بيانات بواسطة عدد من الدوال في لغة البرمجة بايثون وذلك كما يلي:

In:
from matplotlib import image
data = image.imread('C:\Users\img.jpg')
data
Out:
array([[[215, 183, 145],
        [215, 183, 145],
        [215, 183, 145],
        ...,

كذلك يمكن عرض مصفوفة البيانات كصورة باستخداك عدد من الدوال المتوفرة في مكتبات تصوير البيانات وذلك كما يلي:

In:
from matplotlib import pyplot as plt
plt.imshow(data)
plt.show()
Out:

تجريف الويب (web scraping) هو عملية جمع البيانات من الويب بواسطة بعض البرمجيات، وهناك عدد من الدوال والبرمجيات في لغة البرمجة بايثون (Python) التي تساعد في القيام بذلك. في هذا المقال سوف نتعرف على واحدة من أهم تلك الدوال والتي تقوم باستخراج الجداول من مواقع الويب حيث تتميز بسهولة استخدامها وفعاليتها العالية وذلك كما في الكود التالي:

In:
import pandas as pd
df=pd.read_html('https://www.saudiexchange.sa/wps/portal/tadawul/markets/equities/summary/todays-summary?locale=ar')
df[0]
Out:
 	الشركة 	آخر سعر (ر.س) 	التغير 	% التغيير
0 	طباعة وتغليف 	18.50 	1.44 	8.44
1 	الصقر للتأمين 	11.88 	0.72 	6.45
2 	الوطنية    	16.92 	0.92 	5.75
3 	أنعام القابضة 	32.00 	1.55 	5.09
4 	صادرات   	105.00 	4.80 	4.79

داش (Dash) هو إطار عمل مفتوح المصدر يمكن استخدامه لتطوير وبناء واجهات المستخدم لتطبيقات تحليل وتصوير البيانات والذكاء الاصطناعي. وقد تم إصدارها كمكتبة (حزمة) في لغة البرمجة بايثون في عام 2017 من خلال شركة Plotly وتعمل على تطويرها وتحديثها وتقديم الدعم فيما يخص الاستخدام التجاري. لبناء تطبيق باستخدام داش يمكن اتباع الخطوات التالي:

1. تثبيت وتفعيل الحزم اللازمة :

In:
from dash import Dash, html

هذه تمثل فقط الحزم الأساسية وسوف نحتاج حزم  اخرى عند بناء تطبيق اكثر تعقيدا سواء لدعم واجهة التطبيق او لدعم وظائفه المتعلقة بتحليل وتصوير البيانات او الذكاء الاصطناعي.

2. ابتداء التطبيق :

In:
app = Dash(__name__)

3. بناء واجهة التطبيق وتتضمن جميع العناصر ومكونات التطبيق التي سيتم عرضها في متصفح الويب :

In:
app.layout = html.Div([
...
])

4. تشغيل التطبيق:

In:
if __name__ == '__main__':
app.run_server(port=****)

حيث يتم استبدال ****  برقم المنفذ الذي سوف يتم تشغيل التطبيق من خلاله.

مثال(1): بناء تطبيق “Hello World” كما يلي:

In:
from dash import Dash, html

app = Dash(__name__)

app.layout = html.Div([
    html.Div(children='Hello World')
])


if __name__ == '__main__':
    app.run_server(port=2323)

مثال(2): بناء تطبيق لتصوير البيانات:

سوف نستخدم البيانات Breast Cancer Wisconsin Data Set وذلك كما يلي:

In:
from dash import Dash, html, dcc
import pandas as pd
import plotly.express as px

df = pd.read_csv('wdbc.csv',sep=',')

app = Dash(__name__)

app.layout = html.Div([
    dcc.Graph(figure=px.scatter(df, x="concave points_worst", y="symmetry_worst")),
    dcc.Graph(figure=px.pie(df, values='symmetry_worst', names='diagnosis')),   
])

if __name__ == '__main__':
    app.run_server(port=2323)

مكتبة faker هي حزمة متخصصة في البايثون تساعد في توليد بيانات وهمية (dummy data) مثل الاسم، العنوان، الوظيفة، رقم الهاتف، بيانات نصية وغيرها. ويمكن استخدامها من خلال الخطوات التالية:

1. تثبيت وتفعيل مكتبة faker من خلال الكود:

In:
pip install faker
from faker import Faker

2. اعدد النموذج:

In:
fake = Faker()

3. توليد البيانات، مثلاً:

In:
client_name=fake.name()
client_address=fake.address()
description=fake.text()

والتي يمكن طباعتها كما يلي:

In:
print(client_name)
print(client_address)
print(description)
Out:
Cameron Martin
0111 Wright Village
New Thomas, MA 71646
North national million. Somebody drive food job structure could.
Author finally thought activity protect four trouble. Know fish write position health. Create ten professional side.

ملاحظة (1): يمكن تغيير لغة البيانات من خلال اعداد النموذج كما يلي:

In:
fake = Faker('ar')

ليعطي النتيجة التالية:

In:
print(fake.name())
print(fake.address())
print(fake.text())
Out:
كاملة بكر بن وائل
53125 بكر بن عبد مناة Passage
Port وليدhaven, OK 14500
أم فبعد الكونجرس الأوروبية حتى. مقاطعة ممثّلة وبحلول موالية.

ملاحظة (2): يمكن تحديد نمط وعينة البيانات التي سيتم توليد البيانات الوهمية منها وذلك كما في المثال التالي:

In:
from faker.providers import BaseProvider 
import random

class Mydata(BaseProvider):
    def names(self):
        nameslist = ['محمد', 'طارق', 'سالم', 'خالد', 'أنور']
        first_name=random.choice(nameslist)
        second_name=random.choice(nameslist)
        names=first_name+" "+second_name
        return names

    def ID(self):
        key_parts = [str(random.randint(100, 999)) for _ in range(2)]
        return '-'.join(key_parts)
    
fake.add_provider(Mydata)

والذي يعطي النتيجة التالية:

In:
print(fake.names())
print(fake.ID())
Out:
سالم طارق
916-783

في هذا المقال سوف نستعرض بناء تطبيق دردشة (chatbot) وذلك من خلال تطوير تطبيق باستخدام مكتبة داش (Dash) في بايثون وربطه مع ChatGPT المُطور من قبل شركة OpenAI. في البداية نحتاج الى تسجيل حساب في موقع: https://openai.com  للحصول على API يمكن من خلاله الربط مع الخدمة. بعد ذلك يمكن استخدام الكود التالي:

import dash
from dash import dcc
from dash import html
from dash.dependencies import Input, Output 
import openai

# Set the OpenAI info
openai.api_key = '********'  # Replace this with your OpenAI API key
model_engine = '********' # Replace this with your OpenAI engine, or use "text-davinci-003"

# Create the Dash application
app = dash.Dash(__name__)
# Define the layout
app.layout = html.Div(children=[
    html.Div(children=[        
        # App Title
        html.H1(
            children='ChatGPT Application',
            style={
                'textAlign': 'center',
                'color': 'black'
            }
        ),

        # Logo
        html.Img(src='/assets/logo.png', style={'height':'5%', 'width':'5%','float': 'right','marginTop': '-5%'}),
        
        # User's text input field
        dcc.Input(id='user-input', type='text', placeholder='أكتب رسالتك هنا ...',
                  style={
                      'width': '80%', 
                      'height': '40px', 
                      'lineHeight': '40px',
                      'borderRadius': '5px',
                      'border': '2px solid black',
                      'direction': 'rtl',
                      'marginLeft': '10%',
                      'padding': '1%',
                      'marginTop': '5%'

                  }),

        # Submit button
        html.Button('ارسل', id='submit', 
                    style={
                        'display': 'block',
                        'marginRight': '10px', 
                        'background': 'black',
                        'color': 'white',
                        'border': '2px solid black',
                        'borderRadius': '5px',
                        'padding': '10px 20px',
                        'textAlign': 'center',
                        'textDecoration': 'none',
                        'fontSize': '16px',
                        'margin' : '4px 2px',
                        'cursor' : 'pointer'
                    }),

        # Response area
        html.Div(id='openai-response', 
                 style={
                     'backgroundColor': '#f2f2f2f2',
                      'width': '80%', 
                      'height': '40px', 
                      'lineHeight': '40px',
                      'borderRadius': '5px',
                      'border': '2px solid #f2f2f2f2',
                      'direction': 'rtl',
                      'marginLeft': '10%',
                      'marginTop': '20px',
                      'padding': '1%',
                     'fontFamily': 'Tahoma'
                 })
       ],
             
        # Style of the app
        style={
            'width': '80%',
            'margin': 'auto',
            'border': '2px solid black',
            'borderRadius': '5px',
            'padding': '2%',
            'marginTop': '5%',
            'backgroundColor': 'white'
        })   
])

# Define callback to update the response area 
@app.callback(
    Output('openai-response', 'children'),
    [Input('submit', 'n_clicks')],
    [dash.dependencies.State('user-input', 'value')]
)
def update_output(n_clicks, value):
    # If the submit button hasn't been clicked yet
    if n_clicks is None:
        return '...'
    else:
        # If the submit button has been clicked, send the user's message and get the response
        response = openai.Completion.create(
          engine=model_engine,
          prompt=value,
          temperature=0.5,
          max_tokens=100
        )
        # Return and display the response
        return response.choices[0].text.strip()

# Run the application
if __name__ == '__main__':
    app.run_server(host= '0.0.0.0',port=5588)

والذي يعطي النتيجة التالية:
ملاحظة: القيم المحددة في الكود أعلاه باللون الأحمر يمكن تغييرها وهي:

(1) openai.api_key: هو API يسمح للمطورين بربط ChatGPT مع تطبيقاتهم.

(2) model_engine: هو نموذج الذكاء الإصطناعي ويجب أن يتناسب مع حالة الأستخدام المستهدفة مثل الدردشة، الصوت الى نص وغيرها. التفاصيل من خلال الرابط.

(3) Temperature: هي معلمة تتحكم في الإبداع أو التركيز للنص الذي يتم توليده بواسطة ChatGPT. تؤدي قيمته المرتفعة (على سبيل المثال، 0.7) إلى مخرجات أكثر تنوعًا وإبداعًا، في حين أن قيمته المنخفضة (على سبيل المثال، 0.2) تجعل المخرجات أكثر تحديدًا وتركيزًا.

(4) max_tokens: هي معلمة تتحكم في طول مخرجات ChatGPT.

(5) logo.png: ملف الوجو ويخزن في مجلد assets

(6) fontFamily: ملف الخط ويخزن في مجلد assets

لتحليل وتصوير البيانات باستخدام الذكاء الاصطناعي سوف نستخدم مكتبة PandasAI وهي مكتبة في بايثون يمكن من خلالها ربط مكتبة Pandas مع الذكاء الاصطناعي التوليدي. لتوضيح ذلك سوف نستخدم بيانات الناتج المحلي (GDP) لمجموعة من الدول لعام 2022 وذلك كما في الكود التالي:

In:
import pandas as pd 
GDP_data = pd.read_csv('GDP_data.csv',sep=',')
GDP_data.head()
     Country        GDP
0  Australia   1,677.45
1     Brazil   1,810.61
2     Canada   2,189.79
3      China  18,463.13
4     France   3,140.03

حيث يمكن تحميل البيانات المتعلقة بالكود اعلاه من خلال الرابط GDP_data. بعد ذلك سوف يتم الربط مع ChatGPT كما يلي:

In:
from pandasai import SmartDataframe
from pandasai.llm import OpenAI
llm = OpenAI(api_token="******")
df = SmartDataframe(GDP_data, config={"llm": llm})

حيث تستبدل ****** بـ API الخاص بـ ChatGPT. ثم نبدا في استخدام الذكاء الاصطناعي للبحث وتحليل وتصوير البيانات كما يلي:

In:
df.chat("can you describe the data")
Out:
          Country       GDP
count          19        19
unique         19        19
top     Australia  1,677.45
freq            1         1
In:
df.chat('Which are the top 5 GDP countries?')
Out:
           Country       GDP
18   United States  24796.08
3            China  18463.13
9            Japan   5383.68
5          Germany   4557.35
17  United Kingdom   3442.21
In:
df.chat("can visualize 5 highest GDP countries using pie chart with different blue colors?")
Out:

In:
df.chat("what are the two most similar countries?")
Out:
The two most similar countries are Germany and United Kingdom.

لمعالجة وتصوير البيانات بشكل تفاعلي في بايثون يمكن استخدام مكتبة mitosheet وهي حزمة برمجية في لغة البرمجة بايثون يمكن استخدامها مع Jupyter للقيام بمعاينة البيانات ومعالجتها وتصويرها باستخدام اسلوب جداول البيانات (spreadsheet)، كما أنه يتم توليد كود بايثون لكل خطوة يتم القيام بها على البيانات.

كذلك يمكن الربط مع الذكاء الاصطناعي التوليدي ChatGPT وتوظيفة في اجراء بعض العمليات على البيانات :

للبدء في تجربة واستخدام مكتبة mitosheet، يتم تثبيت المكتبة من خلال الكود التالي:

In:
pip install mitosheet

بعد ذلك يمكن تشغيل الحزمة من خلال الكود:

In:
import mitosheet
mitosheet.sheet()

والذي سيقوم بفتح الصفحة التالية:

مكتبة Geopy هي مكتبة في لغة البرمجة بايثون متخصصة في الترميز الجغرافي تساعد في تحديد إحداثيات العناوين والمدن والبلدان والمعالم في جميع أنحاء العالم وذلك من خلال الربط مع مصادر الترميز الجغرافي المختلفة مثل: OpenStreetMap Nominatim و Google Geocoding API (V3) والتي يمكن الاطلاع عليها من خلال الرابط. حيث يمكن في البداية تثبيت الحزمة من خلال الكود:

In:
from geopy import geocoders

 بعد ذلك يتم اعداد أداة تحديد الموقع الجغرافي (geolocator) كما يلي:

In:
geolocator = geocoders.Nominatim(user_agent='myapplication')

حيث يمكن استبدال Nominatim بأي خدمة من مزودي تحديد المواقع الجغرافية الاخرى مثل خرائط Google، أو خرائط Bing، لمزيد من المعلومات استخدم الكود:

help(geocoders)

الان، يمكن تحديد الموقع الجغرافي من خلال الاستعلام عن العناوين والمدن والبلدان والمعالم من خلال الدالة:
geolocator.geocode(query, exactly_one, language, extratags, featuretype, ...)

حيث أن:

فمثلا يمكن تحديد احداثيات “برج المملكة” من خلال الكود:

In:
location = geolocator.geocode('برج المملكة')
print(location.latitude,location.longitude)
Out:
24.71135095 46.674412069179105

او عنوانه من خلال الكود:

In:
location = geolocator.geocode('برج المملكة')
print(location.address)
Out:
برج المملكة, الملك فهد, العليا, بلدية العليا, محافظة الرياض, منطقة الرياض, 12214, السعودية

كذلك يمكن الحصول على البيانات للموقع الجغرافي:

In:
location = geolocator.geocode('برج المملكة')
print(location.raw)
Out:
{'place_id': 72000238, 'licence': 'Data © OpenStreetMap contributors, ODbL 1.0. http://osm.org/copyright', 'osm_type': 'way', 'osm_id': 264745922, 'lat': '24.71135095', 'lon': '46.674412069179105', 'class': 'building', 'type': 'commercial', 'place_rank': 30, 'importance': 0.44095611103381205, 'addresstype': 'building', 'name': 'برج المملكة', 'display_name': 'برج المملكة, الملك فهد, العليا, بلدية العليا, محافظة الرياض, منطقة الرياض, 12214, السعودية', 'boundingbox': ['24.7111133', '24.7115817', '46.6740278', '46.6747950']}

كما يمكن الحصول على نقطة تمثل خطوط الطول والعرض والارتفاع:

In:
location = geolocator.geocode('برج المملكة')
print(location.point)
Out:
24 42m 40.8634s N, 46 40m 27.8834s E

مساعد أناكوندا (Anaconda Assistant) هو إضافة من أناكوندا (Anaconda) تعمل بالتكامل مع إداة Jupyter notebook لتعزيز الانتاجية لمستخدمي منصة Anaconda  من علماء  ومحللي البيانات والمطورين والباحثين. يوفر Anaconda Assistant واجهة دردشة تعتمد على نماذج الذكاء الاصطناعي التوليدي لمساعدة المستخدم على إنشاء الاكواد البرمجية أو شرحها أو تصحيح أخطائها، وذلك من خلال عدد من المزايا:

• بناء الاكواد البرمجية بناء على تعليمات المستخدم لمعالجة وتحليل البيانات وتصويرها.
• التكامل المرن مع إداة Jupyter notebook بما يسهل ارسال الاكواد من واجهة الدردشة الى أداة Jupyter notebook بنقرة زر واحدة وتنفيذها والحصول على المخرجات.
• شرح وتفسير الاكواد وتحسينها، حيث يمكن للمستخدم تحديد أي جزء من الكود الخاص به حيث يقوم Anaconda Assistant بشرحه أو إضافة تعليقات أو اقتراح تحسينات.
• يساعد Anaconda Assistant تشخيص المشكلات البرمجية  في الاكواد واقتراح إصلاحها.

في هذا المقال سوف نستعرض كيفية تصوير البيانات على مستوى مناطق المملكة، وذلك من خلال بيانات السكان SA_population وكذلك من خلال البيانات الجغرافية للمناطق SA_regions. سوف نتبع الخطوات التالية:

اولاً: تحميل المكتبات المطلوبة

In:
import folium
import pandas as pd
import geopandas as gpd

ثانياً: تحميل بيانات السكان والبيانات الجغرافية للمناطق

In:
SA_population = pd.read_csv('media/SA_population.csv',encoding='utf8')
print(SA_population.head(2))
Out:
   الجنسية    المحافظة    المدينة      المنطقة     النوع     السكان
0   سعودي    ميسان  (القان) ابوضروه  مكة المكرمة  أنثى       8
1   سعودي    ميسان  (القان) ابوضروه  مكة المكرمة   ذكر       9

In:
SA_regions=gpd.read_file('media/SA_regions.json')
SA_regions.rename(columns={"name": "المنطقة"}, inplace=True)
print(SA_regions.head(2))
Out:
  المنطقة                                           geometry
0  القصيم  POLYGON ((41.23742 25.47977, 41.24561 25.47945...
1  الرياض  POLYGON ((41.97361 23.85194, 41.97388 23.81028...

ثالثاً: تهيئة البيانات السكانية

من خلال تجميع عدد السكان على مستوى المناطق وكذلك إضافة عمود نسبة سكان كل منطقة من العدد الإجمالي

In:
Regions_population=SA_population.groupby(['المنطقة'], as_index=False)['السكان'].sum()
Regions_population["النسبة"] = round((Regions_population['السكان'] / Regions_population['السكان'].sum()) * 100)
print(Regions_population.head(2))
Out:
  المنطقة   السكان       النسبة
0  الباحة   339174     1.0
1  الجوف   595822     2.0

رابعاً: دمج بيانات السكان والبيانات الجغرافية للمناطق لتسهيل عملية تصويرها

In:
SA_regions_pop=SA_regions.merge(Regions_population,on="المنطقة")
print(SA_regions_pop.head(2))
Out:
   المنطقة                                       geometry       النسبة       السكان        
0  القصيم  POLYGON ((41.23742 25.47977, 41.24561 25.47945...  1336179     4.0
1  الرياض  POLYGON ((41.97361 23.85194, 41.97388 23.81028...  8591748    27.0

خامساً: تصوير البيانات على الخريطة

In:
SA_map = folium.Map(location=[23,45], zoom_start=5, tiles="Stamen Watercolor")
bins = list(SA_regions_pop['النسبة'].quantile([0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]))
choropleth = folium.Choropleth(
    geo_data=SA_regions_pop,
    name='choropleth',
    data=SA_regions_pop,
    columns=['المنطقة', 'النسبة'],
    key_on='feature.properties.المنطقة',
    fill_color='YlGn',
    fill_opacity=0.7,
    line_opacity=0.3, 
    legend_name='التوزيع النسبي للسكان على مستوى المناطق',
    bins=bins,
    reset=True
).add_to(SA_map)

style_function = "font-size: 15px; font-weight: bold"
choropleth.geojson.add_child(
    folium.features.GeoJsonTooltip(['المنطقة','السكان','النسبة'], style=style_function, labels=True))
SA_map

ملاحظة:

من خلال خيار (tiles) يمكن التحكم في عرض واجهة الخريطة ومميزاتتها بما يتناسب مع الأغراض المختلفة كما في الكود أدناه:

folium.TileLayer('Stamen Terrain').add_to(SA_map)
folium.TileLayer('Stamen Toner').add_to(SA_map)
folium.TileLayer('Stamen Water Color').add_to(SA_map)
folium.TileLayer('cartodbpositron').add_to(SA_map)
folium.TileLayer('cartodbdark_matter').add_to(SA_map)
folium.LayerControl().add_to(SA_map)
SA_map

المصادر:
بيانات السكان – الهيئة العامة للاحصاء
البيانات الجغرافية للمناطق – github.com

ماهي حزمة vizro ؟

حزمة  vizro هي إطار عمل مفتوح المصدر لبناء داشبورد او تطبيق ويب للتحليلات التفاعلية بطريقة سهلة وفعالة، وذلك من خلال توظيف حزم برمجية أخرى في بايثون مثل Dash  و Pydantic، مما يساعد على إنشاء لوحات تحليلات وتصوير بيانات تفاعلية متقدمة. حيث أن  vizro تقوم بأتمتة العديد من المهام المتعلقة ببناء تطبيق الويب وتصميم واجهة المستخدم بأسلوب مرن يساعد في حفظ الوقت والجهد.

يتضمن تكوين التطبيق الإعدادات التالية:

• المكونات (components): إنشاء المخططات والجداول وواجهات الإدخال/الإخراج.
• عناصر التحكم (controls):  إنشاء عوامل التصفية ومدخلات البارامترات ووحدات التحكم في الإجراءات المخصصة.
• الصفحات والمخططات والتنقل (pages, layouts and navigation): إنشاء صفحات متعددة، مع مخططات قابلة للتخصيص والتنقل المرن عبرها.
• الإجراءات والتفاعلات (actions and interactions): إنشاء تفاعلات بين المخططات، واستخدام إجراءات محددة مسبقًا أو مخصصة (مثل التصدير).

تطوير تطبيق تحليلات تفاعلية

سوف نقوم بتطوير تطبيق تحليلات تفاعلية لتحليل البيانات  التالية:

والتي يمكن تحميل نسخة منها من خلال الرابط.

بعد ذلك لتطوير تطبيق التحليلات (ذكاء الأعمال) التفاعلي يمكن أن نتبع الخطوات التالية:

1. تفعيل المكتبات المطلوبة لبناء التطبيق

In:
import vizro.plotly.express as px
from vizro import Vizro
import vizro.models as vm

2. استيراد البيانات

In:
import seaborn as sns
df = sns.load_dataset("healthexp")

3. تطوير الصفحات والمخططات والتنقل

In:
# pages, layouts and navigation:
page = vm.Page(
    title="My dashboard",
    # components:
    components=[
        vm.Graph(id="scatter_chart", figure=px.scatter(df, 
                 x="Spending_USD", y="Life_Expectancy", 
                 color="Country")),
        vm.Graph(id="hist_chart", figure=px.histogram(df, 
                 x="Country")),
    ],
    # controls:
    controls=[
        vm.Filter(column="Country", 
                 selector=vm.Dropdown(value=["ALL"])),
    ],
)

4. تشغيل التطبيق

يمكن الوصول لتطبيق التحليلات التفاعلية من خلال:

http://127.0.0.1:8050

وذلك كما في الشكل التالي:

ما هي مكتبة (PandasAI)

هي مكتبة في لغة البرمجة بايثون مفتوحة المصدر يمكن من خلالها معالجة وتحليل البيانات من خلال الدردشة القائمة على الذكاء الاصطناعي (معالجة اللغات الطبيعية)، حيث تستخدم مكتبة (PandasAI) نماذج الذكاء الاصطناعي التوليدي لفهم وتفسير نصوص اللغات الطبيعة وترجمتها إلى أكواد برمجية في (Python or SQL) بحيث تستخدم هذه الأكواد للتفاعل مع البيانات والرد على استفسارات او طلبات المستخدمين. يمكن استخدام مكتبة (PandasAI) للقيام بالتالي:

• الاستفسار والاستعلام من البيانات، حيث يمكن طرح بعض الأسئلة ثم تستخدم نماذج وخوارزميات اللغات الطبيعة للبحث عن إجابه لها من البيانات مثل ما هو عدد سكان دوله معينة؟.
• معالجة وتصوير البيانات، يمكن القيام بمعالجة البيانات مثل معالجة البيانات المفقودة او تنظيف البيانات المتكررة من خلال توجيــه أوامر نصيــة من خــلال الدردشة دون الحــاجة لكتابة أوامــر برمجية. كذلك يمكن استخدام التوجيه النصي لنظام الدردشة القائم على الذكاء الاصطناعي لتحليل وتصوير البيانات وعرض النتائج بطريقة مناسبة.

كيف يمكن استخدام مكتبة (PandasAI)

لتوضيح كيف يمكن استخدام مكتبة (PandasAI) سوف نستخدم بيانات الناتج المحلي  (GDP) لمجموعة من الدول لعام 2022 والتي يمكن تحميلها خلال الرابط. وبعد ذلك يمكن استيرادها كما في الكود التالي:

In:
import pandas as pd 
GDP_data = pd.read_csv('GDP_data.csv',sep=',')
GDP_data.head()
Out:

في البداية سوف يتم إعداد نموذج الذكاء الاصطناعي التوليدي من خلال الربط مع ChatGPT  كما يلي:

In:
from pandasai import SmartDataframe
from pandasai.llm import OpenAI
llm = OpenAI(api_token="******")
df = SmartDataframe(GDP_data, config={"llm": llm})

حيث تستبدل ****** بـ API  الخاص بـ ChatGPT في حسابك.

بعد ذلك يمكن استخدام النموذج كما في الأمثلة التالية:

1. وصف البيانات

In:
df.chat("can you describe the data")
Out:

2. الاستفسار من البيانات

In:
df.chat("Which are the top 5 countries in term of GDP?")
Out:

3. تصوير البيانات

In:
df.chat("can you visualize 10 highest GDP countries using bar chart with skyblue color?")
Out:

4. إضافة عمود جديد

In:
df.chat("can you add new column for country rank based on GDP, and return the first 3 rows?")
Out:

5. حذف بيانات معينة

In:
df.chat("can you remove Australia form data, and return the first 3 rows?")
Out:

مكتبة (lida) هي مكتبة لتصوير البيانات من خلال استخدام تقنيات الذكاء الاصطناعي، حيث تتكامل مع عدد من نماذج اللغات الكبيرة (large language models) مثل (OpenAI, PaLM, Cohere, Huggingface) وكذلك مع مكتبات تصوير البيانات مثل (matplotlib, seaborn, altair, d3).

المصدر: github

للبدء في استخدام مكتبة (lida) يمكن اتباع الخطوات التالية:

اولاً: تثبيت المكتبات المطلوبة

In:
pip install -U lida

اذا كنت تريد استخدام (lida) مع local huggingface models تحتاج تثبيت مكتبة (transformers) كما يلي:

In:
pip install lida[transformers]

ثانياً: تفعيل المكتبات المطلوبة

In:
from lida import Manager, TextGenerationConfig , llm  
import seaborn as sns

ثالثاً: اعداد نموذج الذكاء الاصطناعي

سوف يتم استخدام نماذج الذكاء الاصطناعي من (openai) كما يلي:

In:
lida = Manager(text_gen = llm("openai", api_key="sk-proj-hFcR-0REuopxNZ-Dzj4aEUVQ2T7liZAvhUzWB_o"))
textgen_config = TextGenerationConfig(n=1, temperature=0.2, model="gpt-4o", use_cache=True)
library = "seaborn"

رابعاً: استيراد البيانات
البيانات التي سوف يتم تصويرها من خلال نماذج الذكاء الاصطتاعي هي:

In:
df = sns.load_dataset("healthexp")
print(df.head(3))
Out:
   Year        Country  Spending_USD  Life_Expectancy
0  1970        Germany       252.311             70.6
1  1970         France       192.143             72.2
2  1970  Great Britain       123.993             71.9

والتي يمكن تحميل نسخة منها من خلال الرابط.

خامساً: تلخيص البيانات، وتوليد الأهداف

In:
summary = lida.summarize(df, summary_method="default", textgen_config=textgen_config)  
goals = lida.goals(summary, n=2, textgen_config=textgen_config)

for goal in goals:
    print(goal)
Out:
Goal(question='How has the average spending in USD changed over the years for each country?', visualization="line chart with 'Year' on the x-axis, 'Spending_USD' on the y-axis, and lines colored by 'Country'", rationale="This visualization will help us understand the trend of spending over time for each country. By using 'Year' and 'Spending_USD' fields, we can identify patterns or anomalies in spending behavior across different countries.", index=0) 
Goal(question='Is there a correlation between spending in USD and life expectancy across different countries?', visualization="scatter plot with 'Spending_USD' on the x-axis, 'Life_Expectancy' on the y-axis, and points colored by 'Country'", rationale="This scatter plot will allow us to visually inspect the relationship between spending and life expectancy. By plotting 'Spending_USD' against 'Life_Expectancy' and differentiating by 'Country', we can see if higher spending correlates with higher life expectancy and if this relationship varies by country.", index=1) 

سادساً: تصوير االبيانات كما هو محدد في الأهداف
1. الهدف الأول

In:
i = 0
textgen_config = TextGenerationConfig(n=1, temperature=0.2, use_cache=True)
charts = lida.visualize(summary=summary, goal=goals[i], textgen_config=textgen_config, library=library)  
charts[0]

2. الهدف الثاني

In:
i = 1
textgen_config = TextGenerationConfig(n=1, temperature=0.2, use_cache=True)
charts = lida.visualize(summary=summary, goal=goals[i], textgen_config=textgen_config, library=library)  
charts[0]

ملاحظات هامة:
1. لإنشاء شكل بياني لتصوير البيانات من خلال استعلام المستخدم “user query” يمكن استخدام الكود:

In:
user_query = "what are the averages of spending across different countries?"
textgen_config = TextGenerationConfig(n=1, temperature=0.2, use_cache=True)
charts = lida.visualize(summary=summary, goal=user_query, textgen_config=textgen_config)  
charts[0]

2. يمكن إعطاء النموذج بعض التعليمات، مثلاً تم طلب أن يكون عرض وارتفاع الشكل البياني متساوي وكذلك تغيير لونه الى الأحمر وترجمة الشكل البياني الى العربي مع مراعاة مشكلة عدم دعم بايثون للغة العربية وذلك كما يلي:

In:
code = charts[0].code
textgen_config = TextGenerationConfig(n=1, temperature=0.2, use_cache=True)
instructions = ["make the chart height and width equal", "change the color of the chart to red", "translate the chart to Arabic and solve Arabic not support issues"]
edited_charts = lida.edit(code=code,  summary=summary, instructions=instructions, library=library, textgen_config=textgen_config)
edited_charts[0]

3. يمكن طلب شرح وتفسير الاشكال البيانية كما يلي:

In:
explanations = lida.explain(code=code, library=library, textgen_config=textgen_config) 
for row in explanations[0]:
    print(row["section"]," ** ", row["explanation"])
Out:
accessibility  **  This section of the code is responsible for setting up the physical appearance of the chart. It creates a bar plot with a size of 10x6 inches, uses the 'viridis' color palette for the bars, and sets the x-axis and y-axis labels to 'Country' and 'Average Spending (USD)', respectively. The title of the chart is set to 'Average Spending Across Different Countries'. Additionally, the x-axis labels are rotated by 45 degrees for better readability, and the title is wrapped to fit within the plot area.
transformation  **  This section of the code performs data transformation. It calculates the average spending for each country by grouping the data by the 'Country' column and then computing the mean of the 'Spending_USD' column. The result is reset to a new DataFrame called 'avg_spending', which contains the average spending values for each country.
visualization  **  This section of the code adds annotations to the bar plot. It iterates over each bar in the plot and annotates it with the height value (average spending) formatted to two decimal places. The annotations are positioned at the center of each bar, slightly above the top, with a font size of 10. The 'xytext' and 'textcoords' parameters are used to adjust the position of the annotations.

4. يمكن طلب اقتراح او توصية بشكل بياني (Visualization Recommendation) كما يلي:

In:
textgen_config = TextGenerationConfig(n=2, temperature=0.2, use_cache=True)
recommended_charts =  lida.recommend(code=code, summary=summary, n=2,  textgen_config=textgen_config)
print(f"Recommended {len(recommended_charts)} charts")
for chart in recommended_charts:
    display(chart)

5. يمكن المساهمة في تحديد الاهداف من خلال (persona) كما يلي:

In:
persona = "Analyzing life expectancy in US across years"
personal_goals = lida.goals(summary, n=2, persona=persona, textgen_config=textgen_config)
for goal in personal_goals:
    print(goal)
Out:
Goal(question='How has life expectancy in the US changed over the years?', visualization="line chart of 'Year' vs 'Life_Expectancy'", rationale="By plotting 'Year' on the x-axis and 'Life_Expectancy' on the y-axis, we can observe trends and changes in life expectancy over time. This will help us understand whether life expectancy is improving, declining, or remaining stable in the US.", index=0)
Goal(question='Is there a correlation between healthcare spending and life expectancy in the US?', visualization="scatter plot of 'Spending_USD' vs 'Life_Expectancy'", rationale="By plotting 'Spending_USD' on the x-axis and 'Life_Expectancy' on the y-axis, we can examine the relationship between healthcare spending and life expectancy. This will help us determine if higher spending is associated with longer life expectancy, providing insights into the effectiveness of healthcare investments.", index=1)

مكتبة (pynarrative)  هي حزمة في بايثون تساعد على إضافة سرد قصصي للتحليلات بطريقة سهلة ومؤتمتة من خلال ربط التعليقات التوضيحية والارشادرات التفاعلية بالتغير في البيانات. لتوضيح طريقة عمل هذه الحزمة سوف نقوم في البداية بتفعيل المكتبات المطلوبة كما يلي:

In:
import altair as alt
import pandas as pd
import pynarrative as pn

كذلك سوف نقوم بتحميل البيانات (Monthly_Sales_2024)، واستيرادها كما في الكود:

In:
sales_data = pd.read_csv('Monthly_Sales_2024.csv')
sales_data['Date'] = pd.to_datetime(sales_data['Date'])
print(sales_data.head())
Out:
        Date  Sales                               Note
0 2024-01-01    738                                NaN
1 2024-02-01    907                                NaN
2 2024-03-01    939                                NaN
3 2024-04-01    865  Sales drop due to TAX regulations
4 2024-05-01    976                                NaN

بعد ذلك سوف يتم تصوير البيانات وإضافة السرد القصصي عليها بشكل مباشر من خلال البيانات كما يلي:

In:
# تصوير البيانات
chart = pn.Story(sales_data).mark_line().encode(
    x=alt.X('Date:T', title='Date', axis=alt.Axis(labelFontSize=12, titleFontSize=14)),
    y=alt.Y('Sales:Q', title='Sales ($)', scale=alt.Scale(domain=[600, sales_data['Sales'].max() + 50]),
            axis=alt.Axis(labelFontSize=12, titleFontSize=14))
)

# إضافة السرد القصصي 
filtered_sales_data = sales_data[sales_data['Note'].notna()]
for i in filtered_sales_data.index:
    chart = chart.add_annotation(
        filtered_sales_data['Date'][i], filtered_sales_data['Sales'][i], filtered_sales_data['Note'][i],
        arrow_direction='left', 
        arrow_dx=25, 
        arrow_dy=-1, 
        arrow_color='red', 
        arrow_size=30,
        label_color='red',
        label_dx=45,
        label_dy=-5,
        label_size=14,
        show_point=True
    )

chart.render()