ما هو الموتر في TensorFlow؟ الشكل، النوع، و Operaالاختصاصات

ما هو الموتر؟

الاسم TensorFlow يُشتق هذا المفهوم مباشرةً من جوهره الأساسي: الموتر. في TensorFlow، تتضمن كل عملية حسابية استخدام الموترات. الموتر عبارة عن متجه أو مصفوفة ذات n بُعدًا، يُمثل جميع أنواع البيانات. جميع القيم في الموتر تحمل نوع بيانات متطابقًا، ولها شكل معروف (أو معروف جزئيًا)، وشكل البيانات هو بُعد المصفوفة أو المصفوفة.

يمكن أن ينشأ الموتر من بيانات الإدخال أو من نتيجة عملية حسابية. في TensorFlow، تُجرى جميع العمليات داخل رسم بياني. الرسم البياني عبارة عن مجموعة من العمليات الحسابية التي تتم بالتتابع. تُسمى كل عملية عقدة عملية، وترتبط العقد ببعضها البعض.

يُبيّن الرسم البياني العمليات والروابط بين العُقد، ولكنه لا يُظهر القيم. يُمثّل الخط الواصل بين العُقد الموتر، أي طريقة لتعبئة العملية بالبيانات.

في مجال التعلم الآلي، تُغذّى النماذج بقائمة من الكائنات تُسمى متجهات الميزات. يمكن أن يكون متجه الميزات من أي نوع بيانات، وهو عادةً المدخل الأساسي الذي يُملأ به الموتر. تتدفق هذه القيم إلى عقدة العملية عبر الموتر، وتُنشئ نتيجة تلك العملية موترًا جديدًا، يُستخدم بدوره في عملية جديدة. يمكن عرض جميع هذه العمليات في الرسم البياني.

تمثيل الموتر

في TensorFlow، الموتر عبارة عن مجموعة من متجهات الميزات (أي مصفوفة) ذات n بُعد. على سبيل المثال، إذا كان لدينا مصفوفة 2×3 بقيم من 1 إلى 6، فإننا نكتبها على النحو الموضح أدناه:

يمثل TensorFlow هذه المصفوفة على النحو التالي:

[[1, 2, 3], 
   [4, 5, 6]]

إذا أنشأنا مصفوفة ثلاثية الأبعاد بقيم من 1 إلى 8، فسيتم رسم نفس البيانات على شكل مربع ذي وجهين متراصين:

يمثل TensorFlow هذه المصفوفة على النحو التالي:

[ [[1, 2],  
       [[3, 4],  
       [[5, 6],  
       [[7,8] ]

ملاحظة: يمكن تمثيل الموتر بقيمة عددية أو قد يكون له شكل بأكثر من ثلاثة أبعاد. ببساطة، يصعب تصور مستويات الأبعاد الأعلى.

أنواع الموتر

في TensorFlow، تمر جميع العمليات الحسابية عبر موتر واحد أو أكثر. الموتر tf.Tensor هو كائن له ثلاث خصائص:

• تسمية فريدة (الاسم)
• البعد (الشكل)
• نوع البيانات (dtype)

تتضمن كل عملية تقوم بها باستخدام TensorFlow معالجة موتر. هناك أربعة أنواع رئيسية من الموترات التي يمكنك إنشاؤها:

• tf.Variable
• tf.constant
• tf.placeholder
• tf.SparseTensor

في هذا الدرس التعليمي، ستتعلم كيفية إنشاء tf.constant و tf.Variable.

قبل تشغيل الكود، ضع في اعتبارك نقطة مهمة: يتبع هذا البرنامج التعليمي واجهة برمجة تطبيقات TensorFlow 1.x الأصلية، حيث يتم إنشاء الرسم البياني أولاً ثم تنفيذه لاحقًا داخل جلسة. يعمل TensorFlow 2 بشكل فوري افتراضيًا، لذا تم نقل أو إزالة العديد من الرموز أدناه. لا يزال من الممكن الوصول إلى كل منها من خلال tf.compat.v1 مساحة الاسم، والجدول يربط كل منها بنظيره الحديث.

قبل البدء في البرنامج التعليمي، تأكد من تفعيل بيئة conda التي تم تثبيت TensorFlow عليها. اسم هذه البيئة هو hello-tf.

في عمل macOS المستخدمين:

source activate hello-tf

في عمل Windows المستخدمين:

activate hello-tf

بعد القيام بذلك، ستكون جاهزًا لاستيراد TensorFlow.

# Import tf
import tensorflow as tf

إنشاء موتر من البعد n

تبدأ بإنشاء موتر ذو بعد واحد، وهو العددي.

لإنشاء موتر، يمكنك استخدام tf.constant() كما هو موضح في مثال شكل الموتر في TensorFlow أدناه:

tf.constant(value, dtype, name = "")
arguments

- `value`: Value of n dimension to define the tensor. Optional
- `dtype`: Define the type of data:    
    - `tf.string`: String variable    
    - `tf.float32`: Float variable    
    - `tf.int16`: Integer variable
- "name": Name of the tensor. Optional. By default, `Const_1:0`

لإنشاء موتر ذي بُعد 0، قم بتشغيل الكود التالي.

## rank 0
# Default name
r1 = tf.constant(1, tf.int16) 
print(r1)			

الناتج

Tensor("Const:0", shape=(), dtype=int16)

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

يمكنك أيضًا إعطاء الموتر اسمًا خاصًا بك باستخدام name جدال.

# Named my_scalar
r2 = tf.constant(1, tf.int16, name = "my_scalar") 
print(r2)

الناتج

Tensor("my_scalar:0", shape=(), dtype=int16)

يتم عرض كل موتر باسمه. يتم تعريف كل كائن موتر بخصائص مثل تسمية فريدة (اسم)، وبُعد (شكل)، ونوع بيانات TensorFlow (dtype).

يمكنك تعريف موتر بقيم عشرية أو بسلسلة عن طريق تغيير نوع البيانات.

# Decimal
r1_decimal = tf.constant(1.12345, tf.float32)
print(r1_decimal)
# String
r1_string = tf.constant("Guru99", tf.string)
print(r1_string)

الناتج

Tensor("Const_1:0", shape=(), dtype=float32)
Tensor("Const_2:0", shape=(), dtype=string)

يمكن إنشاء موتر ذي بُعد واحد على النحو التالي:

## Rank 1
r1_vector = tf.constant([1,3,5], tf.int16)
print(r1_vector)
r2_boolean = tf.constant([True, True, False], tf.bool)
print(r2_boolean)

الناتج

Tensor("Const_3:0", shape=(3,), dtype=int16)
Tensor("Const_4:0", shape=(3,), dtype=bool)

يمكنك ملاحظة أن شكل TensorFlow يتكون من عمود واحد فقط.

لإنشاء مصفوفة ثنائية الأبعاد من نوع الموتر، يجب إغلاق الأقواس بعد كل صف. انظر إلى مثال شكل الموتر أدناه.

## Rank 2
r2_matrix = tf.constant([ [1, 2],
                          [3, 4] ],tf.int16)
print(r2_matrix)

الناتج

Tensor("Const_5:0", shape=(2, 2), dtype=int16)

تحتوي المصفوفة على صفين وعمودين مملوءين بالقيم 1 و2 و3 و4.

يتم إنشاء مصفوفة ثلاثية الأبعاد عن طريق إضافة مستوى آخر من الأقواس.

## Rank 3
r3_matrix = tf.constant([ [[1, 2],
                           [3, 4], 
                           [5, 6]] ], tf.int16)
print(r3_matrix)

الناتج

Tensor("Const_6:0", shape=(1, 3, 2), dtype=int16)

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

شكل الموتر

عند طباعة موتر، يستنتج TensorFlow شكله. ومع ذلك، يمكنك قراءة الشكل مباشرةً باستخدام TensorFlow. shape خاصية.

فيما يلي، تقوم بإنشاء مصفوفة مملوءة بالأرقام من 10 إلى 15 وتتحقق من شكلها. m_shape.

# Shape of tensor
m_shape = tf.constant([ [10, 11],
                        [12, 13],
                        [14, 15] ]                      
                     ) 
m_shape.shape

الناتج

TensorShape([Dimension(3), Dimension(2)])

تحتوي المصفوفة على 3 صفوف وعمودين.

يحتوي TensorFlow على أوامر مفيدة لإنشاء متجه أو مصفوفة مملوءة بالرقم 0 أو 1. على سبيل المثال، إذا كنت تريد إنشاء موتر أحادي الأبعاد بشكل محدد 1، مملوء بالرقم 10، يمكنك تشغيل التعليمات البرمجية أدناه:

# Create a vector of 0
print(tf.zeros(10))

الناتج

Tensor("zeros:0", shape=(10,), dtype=float32)

تنطبق هذه الخاصية على المصفوفات أيضًا. هنا، تقوم بإنشاء مصفوفة 10×10 مملوءة بالعدد 1.

# Create a vector of 1
print(tf.ones([10, 10]))

الناتج

Tensor("ones:0", shape=(10, 10), dtype=float32)

يمكنك استخدام شكل مصفوفة معينة لإنشاء متجه من الآحاد. المصفوفة m_shape يحتوي على أبعاد 3×2، لذا فإن الكود التالي ينشئ موترًا بثلاثة صفوف مملوءة بالواحدات:

# Create a vector of ones with the same number of rows as m_shape
print(tf.ones(m_shape.shape[0]))

الناتج

Tensor("ones_1:0", shape=(3,), dtype=float32)

إذا مررت القيمة 1 داخل القوس، فستقوم بإنشاء متجه من الآحاد يساوي عدد الأعمدة في المصفوفة. m_shape.

# Create a vector of ones with the same number of column as m_shape
print(tf.ones(m_shape.shape[1]))

الناتج

Tensor("ones_2:0", shape=(2,), dtype=float32)

وأخيرًا، يمكنك إنشاء مصفوفة 3×2 مملوءة بالكامل بالآحاد.

print(tf.ones(m_shape.shape))

الناتج

Tensor("ones_3:0", shape=(3, 2), dtype=float32)

نوع البيانات

الخاصية الثانية للموتر هي نوع البيانات. لا يمكن للموتر أن يحتوي إلا على نوع واحد من البيانات في كل مرة، ويمكنك قراءة هذا النوع باستخدام dtype خاصية.

print(m_shape.dtype)

الناتج

<dtype: &#x27;int32'>

في بعض الأحيان، قد ترغب في تغيير نوع البيانات. في TensorFlow، هذا ممكن باستخدام tf.cast الأسلوب.

مثال

فيما يلي، يتم تحويل موتر من نوع float إلى عدد صحيح باستخدام cast الأسلوب.

# Change type of data
type_float = tf.constant(3.123456789, tf.float32)
type_int = tf.cast(type_float, dtype=tf.int32)
print(type_float.dtype)
print(type_int.dtype)

الناتج

<dtype: &#x27;float32'>
<dtype: &#x27;int32'>

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

خلق Operaتور

بعض الأدوات المفيدة في TensorFlow Operaالاختصاصات

أنت تعرف كيفية إنشاء موتر باستخدام TensorFlow. حان الوقت لتعلم كيفية إجراء العمليات الحسابية.

يحتوي TensorFlow على جميع العمليات الأساسية. يمكنك البدء بعملية بسيطة واستخدام إحدى دوال TensorFlow لحساب الجذر التربيعي لعدد ما. هذه العملية سهلة لأنها تتطلب وسيطًا واحدًا فقط لإنشاء الموتر.

يُحسب الجذر التربيعي لعدد باستخدام tf.sqrt(x)، حيث x هو عدد عشري.

x = tf.constant([2.0], dtype = tf.float32)
print(tf.sqrt(x))

الناتج

Tensor("Sqrt:0", shape=(1,), dtype=float32)

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

فيما يلي قائمة بالعمليات الشائعة الاستخدام. الفكرة واحدة: كل عملية تتطلب وسيطًا واحدًا أو أكثر.

• tf.add(a, b)
• tf.subtract(a, b)
• tf.multiply(a, b)
• tf.divide(a, b)
• tf.pow(a, b)
• tf.exp(a)
• tf.sqrt(a)

مثال

# Add
tensor_a = tf.constant([[1,2]], dtype = tf.int32)
tensor_b = tf.constant([[3, 4]], dtype = tf.int32)

tensor_add = tf.add(tensor_a, tensor_b)
print(tensor_add)

الناتج

Tensor("Add:0", shape=(1, 2), dtype=int32)

Code تفسير

إنشاء موترين:

• موتر واحد مع 1 و 2
• موتر واحد مع 3 و 4

يمكنك إضافة كلا الموترين.

لاحظ أن كلا الموترين يجب أن يكون لهما نفس الشكل. يمكنك أيضًا إجراء عملية ضرب على الموترين.

# Multiply
tensor_multiply = tf.multiply(tensor_a, tensor_b)
print(tensor_multiply)

الناتج

Tensor("Mul:0", shape=(1, 2), dtype=int32)

المتغيرات

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

لإنشاء متغير، يمكنك استخدام tf.get_variable() الأسلوب.

tf.get_variable(name = "", values, dtype, initializer)
argument
- `name = ""`: Name of the variable
- `values`: Dimension of the tensor
- `dtype`: Type of data. Optional
- `initializer`: How to initialize the tensor. Optional
If initializer is specified, there is no need to include the `values` as the shape of `initializer` is used.

على سبيل المثال، يُنشئ الكود أدناه متغيرًا ثنائي الأبعاد بقيمتين عشوائيتين. افتراضيًا، يُعيد TensorFlow قيمة عشوائية. يمكنك تسمية المتغير var.

# Create a Variable
## Create 2 Randomized values
var = tf.get_variable("var", [1, 2])
print(var.shape)

الناتج

(1, 2)

في هذا المثال، تقوم بإنشاء متغير بصف واحد وعمودين، لذلك تقوم بتمرير [1، 2] كبعد للمتغير.

يمكن أن تكون القيم الأولية للموتر صفرًا أيضًا. عند تدريب نموذج، على سبيل المثال، تحتاج إلى قيم أولية قبل حساب أوزان الميزات. فيما يلي، يتم تعيين هذه القيم الأولية إلى الصفر.

var_init_1 = tf.get_variable("var_init_1", [1, 2], dtype=tf.int32,  initializer=tf.zeros_initializer)
print(var_init_1.shape)

الناتج

(1, 2)

يمكنك أيضًا تمرير قيم موتر ثابت إلى متغير. يمكنك إنشاء موتر ثابت باستخدام الطريقة التالية: tf.constant() واستخدم هذا الموتر لتهيئة المتغير.

القيم الأولى للمتغير هي 10 و 20 و 30 و 40. الموتر الجديد له شكل 2×2.

# Create a 2x2 matrix
tensor_const = tf.constant([[10, 20],
[30, 40]])
# Initialize the first value of the tensor equals to tensor_const
var_init_2 = tf.get_variable("var_init_2", dtype=tf.int32,  initializer=tensor_const)
print(var_init_2.shape)

الناتج

(2, 2)

نائب

يُستخدم العنصر النائب لتغذية الموتر. يقوم العنصر النائب بتهيئة البيانات التي ستتدفق داخل الموترات. لتوفير عنصر نائب، يمكنك استخدام feed_dict يتم إدخال الوسيط، ويتم إدخال العنصر النائب فقط داخل الجلسة.

في المثال التالي، ستتعرف على كيفية إنشاء عنصر نائب باستخدام الطريقة tf.placeholderفي قسم الجلسة، ستتعلم كيفية إدخال قيمة موتر فعلية إلى عنصر نائب.

الصيغة هي:

tf.placeholder(dtype,shape=None,name=None )
arguments:
- `dtype`: Type of data
- `shape`: dimension of the placeholder. Optional. By default, shape of the data
- `name`: Name of the placeholder. Optional			
data_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")
print(data_placeholder_a)

الناتج

Tensor("data_placeholder_a:0", dtype=float32)

جلسة

يعمل TensorFlow حول 3 مكونات رئيسية:

• رسم بياني
• موتر
• جلسة

الرسوم البيانية والجلسات مستقلة. يمكنك تشغيل جلسة والاحتفاظ بالقيم لإجراء حسابات لاحقة.

في المثال أدناه، سوف:

• إنشاء اثنين من الموترات
• إنشاء عملية
• افتح جلسة
• اطبع النتيجة

الخطوة 1) قم بإنشاء موترين x و y

## Create, run  and evaluate a session
x = tf.constant([2])
y = tf.constant([4])

الخطوة الثانية: تقوم بإنشاء العامل بضرب x و y

## Create operator
multiply = tf.multiply(x, y)

الخطوة 3) تقوم بفتح جلسة. تتم جميع العمليات الحسابية داخل الجلسة، وعندما تنتهي، عليك إغلاقها.

## Create a session to run the code
sess = tf.Session()
result_1 = sess.run(multiply)
print(result_1)
sess.close()

الناتج

[8]

Code تفسير

• tf.Session()افتح جلسة. جميع العمليات تتم داخل الجلسة.
• run(multiply): نفّذ العملية التي تم إنشاؤها في الخطوة 2
• print(result_1)وأخيراً، يمكنك طباعة النتيجة
• close()أغلق الجلسة

تظهر النتيجة 8، وهو ضرب x و y.

هناك طريقة أخرى لإنشاء جلسة وهي داخل كتلة برمجية. وتكمن ميزتها في أنها تغلق الجلسة تلقائيًا.

with tf.Session() as sess:
    result_2 = multiply.eval()
print(result_2)

الناتج

[8]

في سياق الجلسة، يمكنك استخدام eval() طريقة لتنفيذ العملية. وهي تعادل run() ويجعل الكود أكثر قابلية للقراءة.

يمكنك إنشاء جلسة ورؤية القيم داخل الموترات التي قمت بإنشائها حتى الآن.

## Check the tensors created before
sess = tf.Session()
print(sess.run(r1))
print(sess.run(r2_matrix))
print(sess.run(r3_matrix))

الناتج

1
[[1 2] 
 [3 4]]
[[[1 2]  
  [3 4]  
  [5 6]]]

تكون المتغيرات فارغة افتراضيًا، حتى بعد إنشاء الموتر. يجب تهيئة المتغير قبل استخدامه. الكائن tf.global_variables_initializer() يتم استدعاء هذه الدالة لتهيئة قيم كل متغير دفعة واحدة، وهو أمر مفيد قبل تدريب النموذج.

يمكنك التحقق من قيم المتغيرات التي أنشأتها سابقًا. لاحظ أنه يجب عليك استخدام الأمر run لتقييم الموتر.

sess.run(tf.global_variables_initializer())
print(sess.run(var))
print(sess.run(var_init_1))
print(sess.run(var_init_2))

الناتج

[[-0.05356491  0.75867283]]
[[0 0]]
[[10 20] 
 [30 40]]

يمكنك استخدام العنصر النائب الذي أنشأته سابقًا وتزويده بقيمة فعلية. عليك تمرير البيانات إلى feed_dict جدال.

على سبيل المثال، سوف تأخذ قوة 2 من العنصر النائب data_placeholder_a.

import numpy as np
power_a = tf.pow(data_placeholder_a, 2)
with tf.Session() as sess:
    data = np.random.rand(1, 10)
    print(sess.run(power_a, feed_dict={data_placeholder_a: data}))  # Will succeed.

Code تفسير

• import numpy as np: قم باستيراد ملف نمباي مكتبة لإنشاء البيانات
• tf.pow(data_placeholder_a, 2): إنشاء العمليات
• np.random.rand(1, 10): إنشاء مصفوفة بيانات عشوائية
• feed_dict={data_placeholder_a: data}قم بتغذية العنصر النائب بالبيانات

الناتج

[[0.05478134 0.27213147 0.8803037  0.0398424  0.21172127 0.01444725  0.02584014 0.3763949  0.66022706 0.7565559 ]]

رسم بياني

يُقدّم TensorFlow كل عملية باستخدام مخطط تدفق البيانات. صُمّم مخطط تدفق البيانات لإظهار تبعيات البيانات بين العمليات الفردية. تتكون الصيغة الرياضية أو الخوارزمية من عدد من العمليات المتتالية، ويُعدّ الرسم البياني وسيلةً ملائمةً لتصوّر كيفية تنسيق هذه العمليات الحسابية.

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

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

لنلقِ نظرة على مثال. تخيل أنك تريد تقييم الدالة التالية:

يقوم TensorFlow بإنشاء رسم بياني لتنفيذ الدالة. يبدو الرسم البياني كالتالي:

يمكنك بسهولة رؤية المسار الذي ستتخذه الموترات للوصول إلى الوجهة النهائية.

على سبيل المثال، add لا يمكن تشغيل Node قبل كل شيء Mul و Pow وقد حققوا نتائجهم. يوضح الرسم البياني أن TensorFlow سيقوم بما يلي:

1. احسب x·z في Mul العقدة و x² في Pow العقدة
2. اجمع هاتين النتيجتين معًا في add العقدة
3. أضف z إلى ذلك المجموع في add_1 العقدة
4. أضف الثابت 5 في add_2 العقدة

x = tf.get_variable("x", dtype=tf.int32,  initializer=tf.constant([5]))
z = tf.get_variable("z", dtype=tf.int32,  initializer=tf.constant([6]))
c = tf.constant([5], name =	"constant")
square = tf.constant([2], name =	"square")
f = tf.multiply(x, z) + tf.pow(x, square) + z + c

Code تفسير

• x: تهيئة متغير يسمى x بقيمة ثابتة 5
• z: تهيئة متغير يسمى z بقيمة ثابتة 6
• ج: تهيئة موتر ثابت يسمى ج بقيمة ثابتة 5
• مربع: قم بتهيئة موتر ثابت يسمى المربع بقيمة ثابتة 2
• f: إنشاء المشغل

في هذا المثال، تُثبَّت قيم المتغيرات. الموتر الثابت c هو المعامل الثابت في الدالة f ويأخذ قيمة ثابتة تساوي 5؛ ويمكنك رؤية هذا المعامل في الرسم البياني ضمن الموتر المسمى ثابت.

تم أيضًا إنشاء موتر ثابت للقوة في المؤثر tf.pow()ليس ذلك ضرورياً، ولكنه يعني أن الأس يظهر في الرسم البياني على شكل دائرة تسمى مربعاً.

من الرسم البياني، يمكنك تتبع ما يحدث للموترات ولماذا تُرجع الدالة 66: 5 × 6 زائد 5² زائد 6 زائد 5 يساوي 66.

يقوم الكود أدناه بتقييم الدالة داخل جلسة.

init = tf.global_variables_initializer() # prepare to initialize all variables
with tf.Session() as sess:
    init.run() # Initialize x and y
    function_result = f.eval()
print(function_result)

الناتج

[66]

دليل سريع لأساسيات TensorFlow

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

إنشاء موتر ثابت

إنشاء عامل

إنشاء موتر متغير

افتح جلسة

الأسئلة الشائعة