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

ما هو الموتر؟

اسم 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، قم بتشغيل following الكود

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

الناتج

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

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

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

يمكن إنشاء موتر البعد 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 يتكون من عمود واحد فقط.

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

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

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

## 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. يمكنك إنشاء موتر مكون من 3 صفوف مملوءة بصفوف واحدة مع المتابعةwing رمز:

# 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 لتنفيذ العمليات.

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

  • tf.add(أ، ب)
  • tf.substract(أ، ب)
  • 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)

شرح الكود

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

  • موتر واحد مع 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) داخل الرسم البياني. يمكنك تخيل الرسم البياني كمشروع تتم فيه كل العمليات. تمثل العقد هذه العمليات، ويمكنها استيعاب أو إنشاء موترات جديدة.
موتر يمثل الموتر البيانات التي تتقدم بين العمليات. لقد رأيت سابقًا كيفية تهيئة الموتر. الفرق بين الثابت والمتغير هو أن القيم الأولية للمتغير سوف تتغير بمرور الوقت.
جلسة ستقوم الجلسة بتنفيذ العملية من الرسم البياني. لتغذية الرسم البياني بقيم الموتر، تحتاج إلى فتح جلسة. داخل الجلسة، يجب عليك تشغيل عامل التشغيل لإنشاء الإخراج.

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

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

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

الخطوة 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]

شرح الكود

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

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

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

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

الناتج

[8]

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

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

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

شرح الكود

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

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

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

دعونا نرى مثالا.

تخيل أنك تريد تقييم المتابعةwing وظيفة:

رسم بياني

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

مثال على الرسم البياني 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

شرح الكود

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

في هذا المثال، نختار الحفاظ على قيم المتغيرات ثابتة. لقد أنشأنا أيضًا موترًا ثابتًا يسمى 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: