TensorFlow คืออะไร? วิธีการทำงานเป็นอย่างไร? Archiเทคเจอร์และคุณสมบัติ

TensorFlow คืออะไร?

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

ปัจจุบัน ไลบรารีการเรียนรู้เชิงลึกที่มีชื่อเสียงที่สุดในโลกคือ GoogleTensorFlow ของ Google บริษัทนำเทคโนโลยีการเรียนรู้ของเครื่องมาใช้ในผลิตภัณฑ์ต่างๆ เพื่อปรับปรุงการค้นหา การแปล การใส่คำบรรยายภาพ และการแนะนำสินค้า

ตัวอย่างเทนเซอร์โฟลว์

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

Google ต้องการใช้แมชชีนเลิร์นนิงเพื่อใช้ประโยชน์จากชุดข้อมูลขนาดใหญ่ของตน เพื่อมอบประสบการณ์ที่ดีที่สุดแก่ผู้ใช้ มีสามกลุ่มที่ใช้แมชชีนเลิร์นนิง:

• นักวิจัย
• นักวิทยาศาสตร์ข้อมูล
• โปรแกรมเมอร์

พวกเขาทั้งหมดสามารถใช้ชุดเครื่องมือเดียวกันเพื่อทำงานร่วมกันและปรับปรุงประสิทธิภาพได้

Google นอกจากจะจัดเก็บชุดข้อมูลขนาดใหญ่แล้ว ยังใช้โครงสร้างพื้นฐานการประมวลผลขนาดมหาศาล ดังนั้น TensorFlow จึงถูกสร้างขึ้นมาให้สามารถขยายขนาดได้ตั้งแต่เริ่มต้น TensorFlow เป็นไลบรารีที่พัฒนาโดย Google ทีม Brain Team เร่งงานวิจัยด้านการเรียนรู้ของเครื่องจักรและโครงข่ายประสาทเทียมเชิงลึก

ถูกสร้างขึ้นเพื่อทำงานบน CPU หรือ GPU หลายตัวและแม้แต่ระบบปฏิบัติการมือถือ และยังมีตัวห่อหุ้มหลายตัวในหลายภาษา เช่น Python, C++ or Java.

ประวัติความเป็นมาของ TensorFlow

เมื่อสองสามปีก่อน การเรียนรู้เชิงลึกเริ่มมีประสิทธิภาพเหนือกว่าอัลกอริธึมการเรียนรู้ของเครื่องอื่นๆ เมื่อได้รับข้อมูลจำนวนมหาศาล Google พบว่าสามารถใช้โครงข่ายประสาทเทียมเชิงลึกเหล่านี้เพื่อปรับปรุงบริการของตนได้:

• Gmail
• ภาพถ่าย
• Google เครื่องมือค้นหา

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

TensorFlow เปิดตัวสู่สาธารณะในเดือนพฤศจิกายน 2015 และเวอร์ชัน 1.0 ตามมาในเดือนกุมภาพันธ์ 2017 การเปลี่ยนแปลงครั้งใหญ่กว่านั้นเกิดขึ้นพร้อมกับ TensorFlow 2.0 ในเดือนกันยายน 2019ซึ่งทำให้การทำงานแบบ eager execution เป็นค่าเริ่มต้น และใช้ Keras เป็น API ระดับสูงมาตรฐาน ตั้งแต่เวอร์ชัน 2.16 เป็นต้นไป Keras 3 เป็นค่าเริ่มต้น และโค้ดโมเดลเดียวกันสามารถทำงานบน JAX หรือ Py ได้เช่นกันTorch แบ็กเอนด์

TensorFlow เผยแพร่ภายใต้ใบอนุญาต Apache 2.0 ดังนั้นคุณสามารถใช้งาน ดัดแปลง และแจกจ่ายต่อได้ รวมถึงการใช้งานเชิงพาณิชย์ โดยไม่ต้องเสียค่าใช้จ่ายใดๆ Google.

TensorFlow ทำงานอย่างไร

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

TensorFlow Archiเทคเจอร์

โครงสร้างของ TensorFlow ประกอบด้วยสามส่วน:

• ประมวลผลข้อมูลล่วงหน้า
• สร้างโมเดล
• ฝึกอบรมและประเมินแบบจำลอง

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

TensorFlow สามารถทำงานได้ที่ไหนบ้าง?

ข้อกำหนดด้านฮาร์ดแวร์และซอฟต์แวร์ของ TensorFlow แบ่งออกเป็นสองขั้นตอน:

ขั้นตอนการพัฒนา Development: ขั้นตอนนี้คือการฝึกโมเดล ซึ่งโดยปกติจะทำบนคอมพิวเตอร์ตั้งโต๊ะหรือแล็ปท็อป

ขั้นตอนการรันหรือการอนุมานเมื่อการฝึกอบรมเสร็จสมบูรณ์ โมเดลสามารถทำงานได้บนหลายแพลตฟอร์ม:

• เดสก์ท็อปทำงานอยู่ Windows, macOS หรือลีนุกซ์
• คลาวด์เป็นบริการบนเว็บ
• อุปกรณ์เคลื่อนที่เช่น iOS และ Android

คุณสามารถฝึกใช้งานบนเครื่องหลายเครื่อง จากนั้นจึงรันบนเครื่องอื่นได้ เมื่อคุณมีโมเดลที่ได้รับการฝึกแล้ว

โมเดลนี้สามารถฝึกฝนและใช้งานได้ทั้งบน GPU และ CPU GPU ถูกออกแบบมาสำหรับวิดีโอเกมเป็นหลัก ต่อมาในปี 2009 นักวิจัยจากสแตนฟอร์ดได้แสดงให้เห็นว่า GPU มีประสิทธิภาพสูงมากในการคำนวณเมทริกซ์และพีชคณิตเชิงเส้น ซึ่งเป็นสิ่งที่โครงข่ายประสาทเทียมต้องพึ่งพา การเรียนรู้เชิงลึกอาศัยการคูณเมทริกซ์เป็นจำนวนมาก TensorFlow มีความเร็วในการคำนวณการคูณเมทริกซ์สูงมาก เนื่องจากเขียนด้วยภาษาโปรแกรมที่เข้าใจง่าย C++- แม้ว่าจะมีการดำเนินการใน C++, TensorFlow สามารถเข้าถึงและควบคุมโดยภาษาอื่นเป็นหลัก Python.

อีกหนึ่งคุณสมบัติที่สำคัญคือ เทนเซอร์บอร์ดซึ่งจะแสดงภาพกราฟ ตัวชี้วัดการฝึกอบรม และการกระจายน้ำหนักขณะที่โมเดลกำลังทำงาน

ส่วนประกอบเทนเซอร์โฟลว์

เมตริกซ์

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

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

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

กราฟ

TensorFlow ใช้เฟรมเวิร์กกราฟ กราฟจะรวบรวมและอธิบายการคำนวณแบบอนุกรมทั้งหมดที่ทำระหว่างการฝึกอบรม กราฟมีข้อดีหลายประการ:

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

เหตุใด TensorFlow จึงเป็นที่นิยม

TensorFlow ได้รับการยอมรับอย่างกว้างขวางเนื่องจากเข้าถึงได้ง่ายสำหรับผู้ใช้ทุกระดับความเชี่ยวชาญ API ของมันครอบคลุมทุกอย่างตั้งแต่โมเดล Keras สามบรรทัดไปจนถึง CNN หรือ RNN ที่สร้างขึ้นด้วยมือ เนื่องจากกระบวนการคำนวณแสดงออกมาในรูปกราฟ TensorBoard จึงสามารถแสดงภาพเครือข่ายและทำให้การดีบักง่ายขึ้นมาก นอกจากนี้ยังสามารถใช้งานได้ในขนาดใหญ่ โดยทำงานบน CPU, GPU และ TPU รวมถึงบนอุปกรณ์พกพาผ่าน TensorFlow Lite

TensorFlow ยังคงเป็นหนึ่งในสองเฟรมเวิร์กการเรียนรู้เชิงลึกที่ใช้กันมากที่สุดบน GitHub ควบคู่ไปกับ PythonTorCH

TensorFlow Algorithms

TensorFlow มาพร้อมกับตัวประมาณค่าระดับสูงสำหรับอัลกอริธึมคลาสสิกหลายตัว ใน TensorFlow เวอร์ชัน 1.x ตัวประมาณค่าเหล่านี้อยู่ภายใต้ชื่อ tf.estimator:

• การถดถอยเชิงเส้น: tf.estimator.LinearRegressor
• การจำแนกประเภท: tf.estimator.LinearClassifier
• การจำแนกการเรียนรู้เชิงลึก: tf.estimator.DNNClassifier
• การเรียนรู้แบบกว้างและลึก: tf.estimator.DNNLinearCombinedClassifier
• การถดถอยแบบต้นไม้เสริมประสิทธิภาพ: tf.estimator.BoostedTreesRegressor
• การจำแนกต้นไม้แบบบูสต์: tf.estimator.BoostedTreesClassifier

TensorFlow เทียบกับ PythonTorch: คุณควรเลือกอันไหนดี?

เทนเซอร์โฟลว์และไพโอนีTorch เป็นเฟรมเวิร์กการเรียนรู้เชิงลึกที่โดดเด่นสองแบบ และความแตกต่างในทางปฏิบัติได้ลดลงอย่างมากนับตั้งแต่ TensorFlow 2.0 นำเอาการประมวลผลแบบ eager execution มาใช้

คำตอบที่ตรงประเด็นคือ: เลือก TensorFlow เมื่อโมเดลต้องใช้งานได้บนมือถือ เว็บเบราว์เซอร์ หรือแพลตฟอร์มการให้บริการแบบจัดการ และเลือก PythonTorโดยเฉพาะอย่างยิ่งเมื่อคุณกำลังปรับปรุงสถาปัตยกรรมของโมเดล Keras 3 ซึ่งเป็นค่าเริ่มต้นตั้งแต่ TensorFlow 2.16 เป็นต้นไป ช่วยลดความยุ่งยากในการตัดสินใจลงไปอีก เนื่องจากโค้ด Keras เดียวกันสามารถทำงานได้บน TensorFlow, JAX หรือ PythonTorส่วนหลังบ้าน (backend) ของ ch

วิธีการคำนวณใน TensorFlow

import numpy as np
import tensorflow as tf

ในโค้ดสองบรรทัดแรก เราได้นำเข้า tensorflow เป็น tf กับ Pythonเป็นเรื่องปกติที่จะใช้ชื่อย่อสำหรับห้องสมุด ข้อดีคือหลีกเลี่ยงการพิมพ์ชื่อเต็มของห้องสมุดเมื่อเราจำเป็นต้องใช้ ตัวอย่างเช่น เราสามารถนำเข้า tensorflow เป็น tf และเรียก tf เมื่อเราต้องการใช้ฟังก์ชัน tensorflow

มาลองฝึกฝนขั้นตอนการทำงานพื้นฐานของ TensorFlow ด้วยตัวอย่างง่ายๆ กัน ลองสร้างกราฟการคำนวณที่คูณตัวเลขสองตัวเข้าด้วยกันดู

ในตัวอย่างนี้ เราจะคูณ X_1 และ X_2 เข้าด้วยกัน TensorFlow จะสร้างโหนดเพื่อเชื่อมต่อการดำเนินการ ในตัวอย่างของเรา โหนดนั้นชื่อว่า multiply เมื่อกำหนดกราฟแล้ว กลไกการคำนวณของ TensorFlow จะคูณ X_1 และ X_2 เข้าด้วยกัน

สุดท้ายนี้ เราจะเรียกใช้เซสชัน TensorFlow ที่จะเรียกใช้กราฟการคำนวณที่มีค่า X_1 และ X_2 และพิมพ์ผลลัพธ์ของการคูณ

เรามานิยามโหนดอินพุต X_1 และ X_2 กัน เมื่อเราสร้างโหนดใน TensorFlow เราต้องเลือกประเภทของโหนดที่จะสร้าง โหนด X1 และ X2 จะเป็นโหนดตัวยึดตำแหน่ง (placeholder node) ตัวยึดตำแหน่งนี้จะกำหนดค่าใหม่ทุกครั้งที่เราทำการคำนวณ เราจะสร้างโหนดเหล่านี้เป็นโหนดตัวยึดตำแหน่งแบบ TF dot

ขั้นตอนที่ 1: กำหนดตัวแปร

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

ตัวแปรแทนที่จำเป็นต้องมีชนิดข้อมูล เนื่องจากเป็นตัวเลข tf.float32 จึงเป็นตัวเลือกที่เหมาะสม ส่วนอาร์กิวเมนต์ name นั้นเป็นตัวเลือกเสริมแต่มีประโยชน์ เพราะเป็นป้ายกำกับที่จะปรากฏในภาพกราฟบน TensorBoard X_2 ก็ถูกกำหนดในลักษณะเดียวกัน

ขั้นตอนที่ 2: กำหนดการคำนวณ

multiply = tf.multiply(X_1, X_2, name = "multiply")

ตอนนี้เราสามารถกำหนดโหนดที่จะทำการคำนวณการคูณได้แล้ว ใน TensorFlow เราสามารถทำได้โดยการสร้างโหนด tf.multiply

เราจะส่งผ่านโหนด X_1 และ X_2 ไปยังโหนดการคูณ โดยจะสั่งให้เทนเซอร์โฟลว์เชื่อมโยงโหนดเหล่านั้นในกราฟการคำนวณ ดังนั้นเราจึงขอให้ดึงค่าจาก x และ y แล้วคูณผลลัพธ์ เรามาตั้งชื่อการคูณให้กับโหนดการคูณด้วย มันคือคำจำกัดความทั้งหมดสำหรับกราฟคำนวณอย่างง่ายของเรา

ขั้นตอนที่ 3: ดำเนินการ

ในการดำเนินการต่างๆ บนกราฟ เราต้องสร้างเซสชันก่อน ใน TensorFlow ทำได้โดยใช้ tf.Session() เมื่อเรามีเซสชันแล้ว เราสามารถขอให้เซสชันนั้นดำเนินการต่างๆ บนกราฟการคำนวณของเราได้โดยการเรียกใช้ session ส่วนการเรียกใช้การคำนวณนั้น เราต้องใช้ run

เมื่อทำการคูณ ระบบต้องการค่าของโหนด X_1 และ X_2 ดังนั้นเราจึงต้องป้อนค่าเหล่านั้นในระหว่างการทำงาน โดยเราสามารถทำได้โดยการส่งพารามิเตอร์ที่ชื่อว่า feed_dict โดยเราส่งค่า 1, 2, 3 สำหรับ X_1 และ 4, 5, 6 สำหรับ X_2

เราพิมพ์ผลลัพธ์ด้วยการพิมพ์(ผลลัพธ์) เราควรเห็น 4, 10 และ 18 สำหรับ 1×4, 2×5 และ 3×6

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

multiply = tf.multiply(X_1, X_2, name = "multiply")

with tf.Session() as session:
    result = session.run(multiply, feed_dict={X_1:[1,2,3], X_2:[4,5,6]})
    print(result)

[ 4. 10. 18.]

ตัวเลือกในการโหลดข้อมูลลงใน TensorFlow

ขั้นตอนแรกก่อนการฝึกก เครื่องอัลกอริทึมการเรียนรู้ คือการโหลดข้อมูล มีสองวิธีหลักในการโหลดข้อมูล:

1. โหลดข้อมูลลงในหน่วยความจำ: นี่เป็นวิธีที่ง่ายที่สุด คุณโหลดข้อมูลทั้งหมดลงในหน่วยความจำในรูปแบบอาร์เรย์เดียว คุณเขียนโค้ดแบบธรรมดา Python สำหรับเรื่องนี้ ไม่มีส่วนใดที่เกี่ยวข้องกับ TensorFlow โดยเฉพาะ

2. ไปป์ไลน์ข้อมูล TensorFlowTensorFlow มี API ในตัวที่โหลดข้อมูล แปลงข้อมูล และป้อนข้อมูลให้กับโมเดล วิธีนี้ใช้งานได้ดีมากโดยเฉพาะอย่างยิ่งเมื่อคุณมีชุดข้อมูลขนาดใหญ่ ตัวอย่างเช่น บันทึกภาพมีขนาดใหญ่มากและไม่สามารถเก็บไว้ในหน่วยความจำได้ทั้งหมด ไปป์ไลน์ข้อมูลจะจัดการหน่วยความจำด้วยตัวเอง

จะใช้โซลูชั่นอะไร?

โหลดข้อมูลในหน่วยความจำ

หากชุดข้อมูลของคุณไม่ใหญ่เกินไป เช่น น้อยกว่า 10 กิกะไบต์ คุณสามารถใช้วิธีแรกได้ ข้อมูลสามารถใส่ลงในหน่วยความจำได้ คุณสามารถใช้ไลบรารีชื่อดังชื่อ Pandas เพื่อนำเข้าไฟล์ CSV คุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับแพนด้าในบทช่วยสอนถัดไป

โหลดข้อมูลด้วยไปป์ไลน์ TensorFlow

วิธีที่สองทำงานได้ดีที่สุดถ้าคุณมีชุดข้อมูลขนาดใหญ่ ตัวอย่างเช่น หากคุณมีชุดข้อมูล 50 กิกะไบต์ และคอมพิวเตอร์ของคุณมีหน่วยความจำเพียง 16 กิกะไบต์ เครื่องก็จะเสียหาย

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

โดยสรุป: โหลดชุดข้อมูลขนาดเล็กเข้าสู่หน่วยความจำด้วย pandas และใช้ไปป์ไลน์ TensorFlow เมื่อข้อมูลมีขนาดใหญ่หรือเมื่อต้องการโหลดแบบขนานบน CPU หลายตัว

วิธีสร้างไปป์ไลน์ TensorFlow

ขั้นตอนในการสร้างไปป์ไลน์ TensorFlow มีดังนี้

ในตัวอย่างก่อนหน้านี้ เราได้เพิ่มค่าสามค่าให้กับ X_1 และ X_2 ด้วยตนเอง ตอนนี้เราจะมาดูวิธีการโหลดข้อมูลไปยัง TensorFlow กัน:

ขั้นตอนที่ 1) สร้างข้อมูล

ก่อนอื่น ลองใช้ไลบรารี numpy เพื่อสร้างค่าสุ่มสองค่า

import numpy as np
x_input = np.random.sample((1,2))
print(x_input)

[[0.8835775 0.23766977]]

ขั้นตอนที่ 2) สร้างตัวยึดตำแหน่ง

เช่นเดียวกับในตัวอย่างก่อนหน้านี้ เราสร้างตัวยึดตำแหน่งด้วยชื่อ X เราจำเป็นต้องระบุรูปร่างของเมตริกซ์อย่างชัดเจน ในกรณีที่เราจะโหลดอาร์เรย์ที่มีค่าเพียงสองค่าเท่านั้น เราสามารถเขียนรูปร่างเป็น shape=[1,2]

# using a placeholder
x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')

ขั้นตอนที่ 3) กำหนดวิธีชุดข้อมูล

ต่อไป เราต้องกำหนดชุดข้อมูลที่เราสามารถเติมค่าของตัวยึด x ได้ เราจำเป็นต้องใช้วิธี tf.data.Dataset.from_tensor_slices

dataset = tf.data.Dataset.from_tensor_slices(x)

ขั้นตอนที่ 4) สร้างไปป์ไลน์

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

iterator = dataset.make_initializable_iterator() 
get_next = iterator.get_next()

ขั้นตอนที่ 5) ดำเนินการ

ขั้นตอนสุดท้ายจะคล้ายกับตัวอย่างก่อนหน้า เราเริ่มเซสชันและเรียกใช้ตัววนซ้ำการดำเนินการ เราป้อนค่าที่สร้างโดย feed_dict ลงใน มึน- ค่าทั้งสองนี้จะเติมตัวยึดตำแหน่ง x จากนั้นเรารัน get_next เพื่อพิมพ์ผลลัพธ์

with tf.Session() as sess:
    # feed the placeholder with data
    sess.run(iterator.initializer, feed_dict={ x: x_input }) 
    print(sess.run(get_next))

[0.8835775  0.23766978]

TensorFlow 1.x เทียบกับ TensorFlow 2.x: มีอะไรเปลี่ยนแปลงบ้าง

TensorFlow 2.0 เป็นการเขียนโค้ด API สำหรับผู้ใช้ใหม่ทั้งหมด การเข้าใจความแตกต่างนี้มีความสำคัญ เพราะโค้ดตัวอย่างจำนวนมากบนอินเทอร์เน็ต รวมถึงตัวอย่างข้างต้นนั้น มุ่งเป้าไปที่รูปแบบของเวอร์ชัน 1.x

ตัวอย่างการคูณที่เขียนใหม่ สามขั้นตอนและเซสชันจะรวมเป็นบรรทัดเดียว เพราะการดำเนินการจะทำงานทันทีที่ถูกเรียกใช้:

import tensorflow as tf

X_1 = tf.constant([1, 2, 3], dtype=tf.float32)
X_2 = tf.constant([4, 5, 6], dtype=tf.float32)

result = tf.multiply(X_1, X_2, name="multiply")
print(result.numpy())        # [ 4. 10. 18.]

กระบวนการรับข้อมูลได้รับการเขียนใหม่แล้ว ไม่จำเป็นต้องมีตัวยึดตำแหน่งหรืออ็อบเจ็กต์ตัววนซ้ำ:

import numpy as np
import tensorflow as tf

x_input = np.random.sample((1, 2))
dataset = tf.data.Dataset.from_tensor_slices(x_input)

for batch in dataset:
    print(batch.numpy())

หากคุณต้องการความเร็วของกราฟที่คอมไพล์แล้ว ให้ห่อฟังก์ชันด้วย `@tf.function` และ `TensorFlow` tracแปลงเป็นไฟล์เดียวโดยอัตโนมัติ สคริปต์เวอร์ชัน 1.x เก่าสามารถเรียกใช้งานได้โดยไม่เปลี่ยนแปลงผ่านเนมสเปซ tf.compat.v1 แม้ว่าเส้นทางนั้นจะใช้สำหรับงานบำรุงรักษาเท่านั้นและไม่ควรนำไปใช้สำหรับงานใหม่

TensorFlow: ประเด็นสำคัญที่ควรทราบ และ Code อ้างอิง

• TensorFlow ความหมาย: TensorFlow เป็นห้องสมุดการเรียนรู้เชิงลึกที่มีชื่อเสียงที่สุดในช่วงไม่กี่ปีที่ผ่านมา ผู้ปฏิบัติงานที่ใช้ TensorFlow สามารถสร้างโครงสร้างการเรียนรู้เชิงลึกใดๆ ได้ เช่น CNN, RNN หรือโครงข่ายประสาทเทียมแบบธรรมดา
• TensorFlow ส่วนใหญ่ถูกใช้งานโดยนักวิชาการ สตาร์ทอัพ และบริษัทขนาดใหญ่ Google ใช้ TensorFlow ในเกือบทุกกรณี Google ผลิตภัณฑ์ที่ใช้ในชีวิตประจำวัน ได้แก่ Gmailภาพถ่ายและ Google เครื่องมือค้นหา.
• การขอ Google ทีม Brain พัฒนา TensorFlow ขึ้นมาเพื่อลดช่องว่างระหว่างนักวิจัยและนักพัฒนาผลิตภัณฑ์ ในปี 2015 พวกเขาเปิดตัว TensorFlow สู่สาธารณะ และได้รับความนิยมอย่างรวดเร็ว ปัจจุบัน TensorFlow เป็นไลบรารีสำหรับการเรียนรู้เชิงลึกที่มีคลังเก็บโค้ดมากที่สุดบน GitHub
• ผู้ใช้งานระดับมืออาชีพใช้ TensorFlow เพราะสามารถปรับใช้ได้อย่างง่ายดายในระดับใหญ่ ทั้งบนคลาวด์ ในเบราว์เซอร์ หรือบนอุปกรณ์เคลื่อนที่ที่ใช้ iOS และ Android.

TensorFlow ทำงานในรูปแบบเซสชัน แต่ละเซสชันถูกกำหนดโดยกราฟที่มีการคำนวณที่แตกต่างกัน ตัวอย่างง่ายๆ คือการคูณตัวเลข ใน TensorFlow ต้องใช้สามขั้นตอนดังนี้:

1. กำหนดตัวแปร

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

2. กำหนดการคำนวณ

multiply = tf.multiply(X_1, X_2, name = "multiply")

3. ดำเนินการการดำเนินการ

with tf.Session() as session:
    result = session.run(multiply, feed_dict={X_1: [1, 2, 3], X_2: [4, 5, 6]})
    print(result)

หนึ่งในวิธีปฏิบัติทั่วไปใน TensorFlow คือการสร้างไปป์ไลน์เพื่อโหลดข้อมูล หากคุณทำตามห้าขั้นตอนต่อไปนี้ คุณจะสามารถโหลดข้อมูลไปยัง TensorFlow ได้:

1. สร้างข้อมูล

import numpy as np
x_input = np.random.sample((1,2))
print(x_input)

2. สร้างตัวยึดตำแหน่ง

x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')

3. กำหนดวิธีชุดข้อมูล

dataset = tf.data.Dataset.from_tensor_slices(x)

4. สร้างไปป์ไลน์

iterator = dataset.make_initializable_iterator()
get_next = iterator.get_next()

5. รันโปรแกรม

with tf.Session() as sess:
    sess.run(iterator.initializer, feed_dict={x: x_input})
    print(sess.run(get_next))

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