Tensor ใน TensorFlow คืออะไร? รูปร่าง ประเภท และ... Operaโปร

เทนเซอร์คืออะไร?

ชื่อ TensorFlow TensorFlow ถูกสร้างขึ้นโดยตรงจากวัตถุหลักของมัน นั่นคือ เทนเซอร์ ใน TensorFlow ทุกการคำนวณเกี่ยวข้องกับเทนเซอร์ เทนเซอร์คือเวกเตอร์หรือเมทริกซ์ที่มีมิติ n ซึ่งแสดงถึงข้อมูลทุกประเภท ค่าทั้งหมดในเทนเซอร์มีชนิดข้อมูลเดียวกันและมีรูปร่างที่ทราบ (หรือทราบบางส่วน) โดยรูปร่างของข้อมูลคือมิติของเมทริกซ์หรืออาร์เรย์

เทนเซอร์สามารถเกิดขึ้นได้จากข้อมูลอินพุตหรือจากผลลัพธ์ของการคำนวณ ใน TensorFlow การดำเนินการทั้งหมดจะเกิดขึ้นภายในกราฟ กราฟคือชุดของการคำนวณที่เกิดขึ้นต่อเนื่องกัน การดำเนินการแต่ละครั้งเรียกว่าโหนด op และโหนดเหล่านี้เชื่อมต่อกัน

กราฟแสดงโครงร่างของการดำเนินการและการเชื่อมต่อระหว่างโหนดต่างๆ อย่างไรก็ตาม กราฟไม่ได้แสดงค่าต่างๆ เส้นเชื่อมระหว่างโหนดคือเทนเซอร์ กล่าวคือ วิธีการเติมข้อมูลลงในการดำเนินการนั้น

ในแมชชีนเลิร์นนิง โมเดลจะได้รับรายการของวัตถุที่เรียกว่าเวกเตอร์คุณลักษณะ เวกเตอร์คุณลักษณะสามารถเป็นข้อมูลประเภทใดก็ได้ และโดยปกติจะเป็นอินพุตหลักที่ใช้เติมข้อมูลลงในเทนเซอร์ ค่าเหล่านี้จะไหลเข้าสู่โหนดการดำเนินการผ่านทางเทนเซอร์ และผลลัพธ์ของการดำเนินการนั้นจะสร้างเทนเซอร์ใหม่ ซึ่งจะถูกนำไปใช้ในการดำเนินการใหม่ต่อไป การดำเนินการทั้งหมดเหล่านี้สามารถมองเห็นได้ในกราฟ

การเป็นตัวแทนของเทนเซอร์

ใน 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.

สิ่งหนึ่งที่ควรทราบก่อนรันโค้ดคือ บทช่วยสอนนี้ใช้ API ของ TensorFlow 1.x ดั้งเดิม ซึ่งจะสร้างกราฟก่อนแล้วจึงรันในภายหลังภายในเซสชัน TensorFlow 2 ทำงานแบบ eagerly (รันทันที) โดยค่าเริ่มต้น ดังนั้นสัญลักษณ์บางส่วนด้านล่างจึงถูกย้ายหรือลบออกไป แต่ทุกสัญลักษณ์ยังคงสามารถเข้าถึงได้ผ่านทางโค้ด 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)

สามารถสร้างเทนเซอร์ที่มีมิติ 1 ได้ดังนี้:

## 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 ประกอบด้วยคอลัมน์เพียง 1 คอลัมน์เท่านั้น

ในการสร้างอาร์เรย์เทนเซอร์ 2 มิติ คุณต้องปิดวงเล็บหลังแต่ละแถว ดูตัวอย่างรูปร่างเทนเซอร์ด้านล่าง

## 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 และ 4

เมทริกซ์ 3 มิติถูกสร้างขึ้นโดยการเพิ่มวงเล็บอีกระดับหนึ่ง

## 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 แถว 2 คอลัมน์

TensorFlow มีคำสั่งที่มีประโยชน์ในการสร้างเวกเตอร์หรือเมทริกซ์ที่เต็มไปด้วย 0 หรือ 1 ตัวอย่างเช่น หากคุณต้องการสร้างเทนเซอร์ 1 มิติที่มีรูปร่างเฉพาะเจาะจงเป็น 10 และเต็มไปด้วย 0 คุณสามารถเรียกใช้โค้ดด้านล่างได้:

# 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 แถวซึ่งเต็มไปด้วยเลข 1:

# 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 เข้าไปในวงเล็บ คุณจะได้เวกเตอร์ที่มีค่าเป็น 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)

สุดท้าย คุณสามารถสร้างเมทริกซ์ขนาด 3x2 ที่บรรจุด้วยเลข 1 ทั้งหมดได้

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 จะเดาประเภทข้อมูลที่น่าจะเป็นไปได้มากที่สุด เช่น หากคุณส่งข้อความเข้าไป มันจะเดาว่าเป็นสตริง

การสร้าง OperaTor

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)

ตัวแปร

ที่ผ่านมา คุณสร้างได้แต่เทนเซอร์แบบคงที่ ซึ่งมีประโยชน์จำกัด ข้อมูลจะเข้ามาด้วยค่าที่แตกต่างกันเสมอ และเพื่อบันทึกค่าเหล่านั้น คุณสามารถใช้คลาส Variable ได้ ตัวแปรแสดงถึงโหนดที่มีค่าเปลี่ยนแปลงไปตามเวลา

ในการสร้างตัวแปร คุณสามารถใช้ 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)

ตัวยึด

ตัวแปรแทนที่ (placeholder) มีจุดประสงค์เพื่อป้อนข้อมูลให้กับเทนเซอร์ ตัวแปรแทนที่ทำหน้าที่เริ่มต้นข้อมูลที่จะไหลเข้าไปในเทนเซอร์ ในการใส่ตัวแปรแทนที่ คุณจะใช้... feed_dict การโต้แย้ง และตัวแปรแทนที่จะถูกส่งเข้าไปเฉพาะภายในเซสชันเท่านั้น

ในตัวอย่างถัดไป คุณจะได้เห็นวิธีการสร้างตัวยึดตำแหน่งด้วยวิธีการดังกล่าว tf.placeholderในส่วน Session คุณจะได้เรียนรู้วิธีป้อนค่าเทนเซอร์จริงลงในตัวแปร 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])

ขั้นตอนที่ 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
• 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 ของ placeholder 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 โหนดไม่สามารถทำงานได้ก่อนทั้งสองอย่าง 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
• c: เริ่มต้นเทนเซอร์คงที่ที่เรียกว่า c โดยมีค่าคงที่เท่ากับ 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

ตารางทั้งสี่ด้านล่างนี้รวบรวมคำสั่งทั้งหมดที่ใช้ในบทช่วยสอนนี้ เพื่อให้คุณสามารถค้นหาคำสั่งที่ต้องการได้โดยไม่ต้องเลื่อนกลับไปดูตัวอย่างทั้งหมด

สร้างเทนเซอร์คงที่

สร้างตัวดำเนินการ

สร้างเทนเซอร์แปรผัน

เปิดเซสชัน

คำถามที่พบบ่อย