أساسيات TensorFlow: الموتر والشكل والنوع والجلسات Operaالاختصاصات

ما هو الموتر؟

اسم Tensorflow مشتق مباشرة من إطاره الأساسي: Tensor. في 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 متغير
• tf ثابت
• tf
• tf.SparseTensor

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

قبل أن ننتقل إلى البرنامج التعليمي، تأكد من تنشيط بيئة 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)

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

الناتج

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

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

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

# 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)

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

## Rank 1r1_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 يتكون من عمود واحد فقط.

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

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

الناتج

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

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

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

## 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)

تبدو المصفوفة مثل الصورة الثانية.

شكل الموتر

عند طباعة Tensor، يخمن TensorFlow الشكل. ومع ذلك، يمكنك الحصول على شكل الموتر باستخدام خاصية الشكل TensorFlow.

أدناه، تقوم بإنشاء مصفوفة مليئة برقم من 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: 'int32'>

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

مثال

أدناه، يتم تحويل الموتر العائم إلى عدد صحيح باستخدام الطريقة 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: 'float32'>
<dtype: 'int32'>

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

عامل إنشاء

بعض مشغلات TensorFlow المفيدة

أنت تعرف كيفية إنشاء موتر باستخدام 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(أ، ب)
• tf.substracفاتورة غير مدفوعة)
• tf.multiply (أ، ب)
• tf.div(أ، ب)
• tf.pow (أ، ب)
• tf.exp(أ)
• tf.sqrt (أ)

مثال

# 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 matrixtensor_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 مكونات رئيسية:

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

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

الرسوم البيانية والجلسات مستقلة. يمكنك تشغيل جلسة والحصول على القيم لاستخدامها لاحقًا في المزيد من العمليات الحسابية.

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

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

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

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

الخطوة 2) يمكنك إنشاء المشغل عن طريق ضرب 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.
• طباعة (result_1): أخيرًا، يمكنك طباعة النتيجة
• إغلاق (): إغلاق الجلسة

تظهر النتيجة 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 تفسير

• استيراد numpy كـ np: Import مكتبة numpy لإنشاء البيانات
• 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 بإنشاء رسم بياني لتنفيذ الوظيفة. الرسم البياني يبدو مثل هذا:

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

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

1. حساب و:
2. أضف 1) معًا
3. إضافة إلى 2)
4. إضافة 3) إلى

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.

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

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 يعمل حول:

• رسم بياني:بيئة حسابية تحتوي على العمليات والموترات
• موتر: يمثل البيانات (أو القيمة) التي ستتدفق في الرسم البياني. إنها الحافة في الرسم البياني
• الجلسات:السماح بتنفيذ العمليات

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

ثابت	موضوع
D0	tf.constant(1, tf.int16)
D1	tf.constant([1,3,5]، tf.int16)
D2	tf.constant([ [1, 2], [3, 4] ],tf.int16)
D3	tf.constant([[[1, 2],[3, 4], [5, 6]] ], tf.int16)

إنشاء عامل

إنشاء عامل	هدف
أ + ب	tf.add(أ، ب)
أ * ب	tf.multiply (أ، ب)

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

قم بإنشاء متغير	موضوع
قيمة عشوائية	tf.get_variable("فار"، [1، 2])
القيمة الأولى التي تمت تهيئتها	tf.get_variable("var_init_2"، dtype=tf.int32، المُهيئ=[ [[1, 2], [3, 4] ])

افتح جلسة

جلسة	موضوع
إنشاء جلسة	tf.Session ()
تشغيل جلسة	tf.Session.run()
تقييم الموتر	متغير_name.eval()
إغلاق الجلسة	إغلاق ()
الجلسة حسب الكتلة	مع tf.Session() كـ sess: