ข้อมูลพื้นฐานเกี่ยวกับ TensorFlow: เทนเซอร์ รูปร่าง ประเภท เซสชัน & Operaโปร
เอเวลิน คลาร์ก
เทนเซอร์คืออะไร?
ชื่อของ Tensorflow ได้มาจากเฟรมเวิร์กหลักโดยตรง: Tensor ใน Tensorflow การคำนวณทั้งหมดเกี่ยวข้องกับเทนเซอร์ เทนเซอร์คือเวกเตอร์หรือเมทริกซ์ที่มีขนาด n มิติซึ่งแสดงถึงข้อมูลทุกประเภท ค่าทั้งหมดในเทนเซอร์จะมีประเภทข้อมูลที่เหมือนกันและมีรูปร่างที่รู้จัก (หรือเป็นที่รู้จักบางส่วน) รูปร่างของข้อมูลคือมิติของเมทริกซ์หรืออาเรย์
เทนเซอร์สามารถเริ่มต้นได้จากข้อมูลอินพุตหรือผลลัพธ์ของการคำนวณ ใน TensorFlow การดำเนินการทั้งหมดจะดำเนินการภายในกราฟ กราฟคือชุดการคำนวณที่เกิดขึ้นต่อเนื่องกัน การดำเนินการแต่ละอย่างเรียกว่าโหนด op และเชื่อมต่อถึงกัน
กราฟจะแสดงโครงร่างของการดำเนินการและการเชื่อมต่อระหว่างโหนด อย่างไรก็ตาม กราฟจะไม่แสดงค่า ขอบของโหนดคือเทนเซอร์ ซึ่งเป็นวิธีในการเติมข้อมูลลงในการดำเนินการ
ในการเรียนรู้ของเครื่อง โมเดลจะถูกป้อนด้วยรายการของอ็อบเจ็กต์ที่เรียกว่าเวกเตอร์คุณลักษณะ เวกเตอร์คุณลักษณะสามารถเป็นประเภทข้อมูลใดก็ได้ เวกเตอร์คุณลักษณะมักจะเป็นอินพุตหลักในการเติมเทนเซอร์ ค่าเหล่านี้จะไหลเข้าสู่โหนด 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.ตัวแปร
- tf.คงที่
- tf.ตัวยึดตำแหน่ง
- tf.SparseTensor
ในบทช่วยสอนนี้ คุณจะได้เรียนรู้วิธีสร้าง tf.constant และ tf.Variable
ก่อนที่เราจะเข้าสู่บทช่วยสอน ตรวจสอบให้แน่ใจว่าคุณเปิดใช้งานสภาพแวดล้อม conda ด้วย TensorFlow เราตั้งชื่อสภาพแวดล้อมนี้ว่า hello-tf
สำหรับผู้ใช้ MacOS:
source activate hello-tf
สำหรับ Windows ผู้ใช้:
activate hello-tf
หลังจากที่คุณทำเสร็จแล้ว คุณก็พร้อมที่จะนำเข้าเทนเซอร์โฟลว์
# 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 (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 ประกอบด้วย 1 คอลัมน์เท่านั้น
หากต้องการสร้างอาร์เรย์ของมิติเทนเซอร์ 2 มิติ คุณต้องปิดวงเล็บหลังแต่ละแถว ดูตัวอย่างรูปร่างของเทนเซอร์ 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, 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
ด้านล่างนี้ คุณสร้างเมทริกซ์ที่เต็มไปด้วยตัวเลขตั้งแต่ 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)
คุณสามารถใช้รูปร่างของเมทริกซ์ที่กำหนดเพื่อสร้างเวกเตอร์ของ 3 ได้ เมทริกซ์ m_shape คือมิติ 2×3 คุณสามารถสร้างเทนเซอร์ที่มี XNUMX แถวซึ่งถูกเติมด้วย XNUMX โดยใช้โค้ดต่อไปนี้:
# 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
ตัวอย่าง
ด้านล่าง เทนเซอร์โฟลตจะถูกแปลงเป็นจำนวนเต็มโดยใช้วิธีการส่ง
# 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.เพิ่ม (ก, ข)
- tf.substract(ก, ข)
- tf.คูณ(ก, ข)
- 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) ทั้งหมดดำเนินการภายในกราฟ คุณสามารถจินตนาการถึงกราฟเป็นโครงการที่ดำเนินการทุกอย่างเสร็จสิ้น โหนดแสดงถึง 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]
คำอธิบายรหัส
- tf.Session(): เปิดเซสชัน การดำเนินการทั้งหมดจะดำเนินไปภายในเซสชัน
- รัน(คูณ): ดำเนินการตามการดำเนินการที่สร้างไว้ในขั้นตอนที่ 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.
คำอธิบายรหัส
- นำเข้าจำนวนมากเป็น 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 ไม่สามารถดำเนินการได้ก่อน และ กราฟจะอธิบายว่าจะ:
- คำนวณและ:
- เพิ่ม 1) เข้าด้วยกัน
- เพิ่มเป็น 2)
- เพิ่ม 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
- c: เริ่มต้นเทนเซอร์คงที่ที่เรียกว่า c โดยมีค่าคงที่เท่ากับ 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.ค่าคงที่(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) |
สร้างตัวดำเนินการ
| สร้างตัวดำเนินการ | วัตถุ |
|---|---|
| a + b | tf.เพิ่ม (ก, ข) |
| ก * ข | tf.คูณ(ก, ข) |
สร้างเทนเซอร์แปรผัน
| สร้างตัวแปร | วัตถุ |
|---|---|
| ค่าสุ่ม | tf.get_variable(“var”, [1, 2]) |
| เริ่มต้นค่าแรก | tf.get_variable(“var_init_2”, dtype=tf.int32, Initializer=[ [1, 2], [3, 4] ]) |
เปิดเซสชัน
| เซสชั่น | วัตถุ |
|---|---|
| สร้างเซสชัน | tf เซสชัน () |
| เรียกใช้เซสชั่น | tf.เซสชัน.รัน() |
| ประเมินเทนเซอร์ | ตัวแปร_name.eval() |
| ปิดเซสชัน | เซส.ปิด() |
| เซสชันต่อบล็อก | ด้วย tf.Session() เป็น sess: |
