TensorFlow คือไลบรารีซอฟต์แวร์โอเพ่นซอร์สที่สร้างโดย Google ซึ่งใช้เพื่อใช้ระบบแมชชีนเลิร์นนิงและระบบการเรียนรู้เชิงลึก ชื่อทั้งสองนี้ประกอบด้วยอัลกอริธึมอันทรงพลังชุดหนึ่งซึ่งมีความท้าทายร่วมกันเพื่อให้คอมพิวเตอร์เรียนรู้วิธีระบุรูปแบบที่ซับซ้อนโดยอัตโนมัติและ / หรือทำการตัดสินใจได้ดีที่สุด
หากคุณสนใจรายละเอียดเกี่ยวกับระบบเหล่านี้คุณสามารถเรียนรู้เพิ่มเติมได้จากบล็อกโพสต์ของ ApeeScape บน การเรียนรู้ของเครื่อง และ การเรียนรู้เชิงลึก .
TensorFlow ซึ่งเป็นหัวใจของมันคือไลบรารีสำหรับการเขียนโปรแกรมกระแสข้อมูล ใช้ประโยชน์จากเทคนิคการเพิ่มประสิทธิภาพต่างๆเพื่อให้การคำนวณนิพจน์ทางคณิตศาสตร์ง่ายขึ้นและมีประสิทธิภาพมากขึ้น
คุณสมบัติที่สำคัญบางประการของ TensorFlow ได้แก่ :
- ทำงานได้อย่างมีประสิทธิภาพกับนิพจน์ทางคณิตศาสตร์ที่เกี่ยวข้องกับอาร์เรย์หลายมิติ
- การสนับสนุนที่ดีสำหรับเครือข่ายประสาทเทียมเชิงลึกและแนวคิดการเรียนรู้ของเครื่อง
- การประมวลผล GPU / CPU ที่สามารถเรียกใช้รหัสเดียวกันบนทั้งสองสถาปัตยกรรม
- ความสามารถในการปรับขนาดสูงของการคำนวณข้ามเครื่องและชุดข้อมูลขนาดใหญ่
คุณสมบัติเหล่านี้ร่วมกันทำให้ TensorFlow เป็นเฟรมเวิร์กที่สมบูรณ์แบบสำหรับระบบอัจฉริยะของเครื่องจักรในระดับการผลิต
ในบทช่วยสอน TensorFlow นี้คุณจะได้เรียนรู้วิธีที่คุณสามารถใช้วิธีการเรียนรู้ของเครื่องที่เรียบง่าย แต่ทรงพลังใน TensorFlow และวิธีที่คุณสามารถใช้ไลบรารีเสริมบางส่วนเพื่อแก้ไขจุดบกพร่องแสดงภาพและปรับแต่งโมเดลที่สร้างขึ้นด้วย
การติดตั้ง TensorFlow
เราจะใช้ TensorFlow Python API ซึ่งทำงานร่วมกับ Python 2.7 และ Python 3.3+ เวอร์ชัน GPU (Linux เท่านั้น) ต้องใช้ Cuda Toolkit 7.0+ และ cuDNN v2 +
เราจะใช้ระบบการจัดการการพึ่งพาแพ็คเกจ Conda เพื่อติดตั้ง TensorFlow Conda ช่วยให้เราสามารถแยกสภาพแวดล้อมต่างๆในเครื่องได้ คุณสามารถเรียนรู้วิธีการติดตั้ง Conda ได้จาก ที่นี่ .
หลังจากติดตั้ง Conda แล้วเราสามารถสร้างสภาพแวดล้อมที่เราจะใช้สำหรับการติดตั้งและใช้งาน TensorFlow คำสั่งต่อไปนี้จะสร้างสภาพแวดล้อมของเราด้วยไลบรารีเพิ่มเติมเช่น NumPy ซึ่งมีประโยชน์มากเมื่อเราเริ่มใช้ TensorFlow
เวอร์ชัน Python ที่ติดตั้งภายในสภาพแวดล้อมนี้คือ 2.7 และเราจะใช้เวอร์ชันนี้ในบทความนี้
conda create --name TensorflowEnv biopython เพื่อให้ง่ายขึ้นเรากำลังติดตั้ง biopython ที่นี่แทนที่จะเป็น NumPy ซึ่งรวมถึง NumPy และแพ็คเกจอื่น ๆ ที่เราต้องการ คุณสามารถติดตั้งแพ็กเกจได้ตลอดเวลาตามที่คุณต้องการโดยใช้ conda install หรือ pip install คำสั่ง
คำสั่งต่อไปนี้จะเปิดใช้งานสภาพแวดล้อม Conda ที่สร้างขึ้น เราจะสามารถใช้แพ็คเกจที่ติดตั้งภายในโดยไม่ต้องผสมกับแพ็คเกจที่ติดตั้งทั่วโลกหรือในสภาพแวดล้อมอื่น ๆ
source activate TensorFlowEnv เครื่องมือติดตั้ง pip เป็นส่วนมาตรฐานของสภาพแวดล้อม Conda เราจะใช้เพื่อติดตั้งไลบรารี TensorFlow ก่อนที่จะดำเนินการขั้นตอนแรกที่ดีคือการอัปเดต pip เป็นเวอร์ชันล่าสุดโดยใช้คำสั่งต่อไปนี้:
pip install --upgrade pip ตอนนี้เราพร้อมที่จะติดตั้ง TensorFlow แล้วโดยเรียกใช้:
pip install tensorflow การดาวน์โหลดและสร้าง TensorFlow อาจใช้เวลาหลายนาที ในขณะที่เขียนสิ่งนี้จะติดตั้ง TensorFlow 1.1.0
กราฟการไหลของข้อมูล
ใน TensorFlow การคำนวณจะอธิบายโดยใช้กราฟการไหลของข้อมูล แต่ละโหนดของกราฟแสดงถึงอินสแตนซ์ของการดำเนินการทางคณิตศาสตร์ (เช่นการบวกการหารหรือการคูณ) และแต่ละขอบคือชุดข้อมูลหลายมิติ (เทนเซอร์) ที่ดำเนินการ
เนื่องจาก TensorFlow ทำงานร่วมกับกราฟการคำนวณจึงมีการจัดการโดยที่แต่ละโหนดแสดงถึงอินสแตนซ์ของการดำเนินการโดยแต่ละการดำเนินการมีอินพุตเป็นศูนย์หรือมากกว่าและมีเอาต์พุตเป็นศูนย์หรือมากกว่า
ขอบใน TensorFlow สามารถจัดกลุ่มได้เป็นสองประเภท: ขอบปกติถ่ายโอนโครงสร้างข้อมูล (เทนเซอร์) ซึ่งเป็นไปได้ที่ผลลัพธ์ของการดำเนินการหนึ่งจะกลายเป็นอินพุตสำหรับการดำเนินการอื่นและขอบพิเศษซึ่งใช้เพื่อควบคุมการพึ่งพาระหว่างสองโหนดเพื่อตั้งค่า ลำดับการทำงานที่โหนดหนึ่งรอให้อีกโหนดเสร็จสิ้น
นิพจน์ทั่วไป
ก่อนที่เราจะไปพูดถึงองค์ประกอบของ TensorFlow เราจะทำเซสชั่นของการทำงานกับ TensorFlow ก่อนเพื่อให้เข้าใจว่าโปรแกรม TensorFlow มีลักษณะอย่างไร
เริ่มต้นด้วยนิพจน์ง่ายๆและสมมติว่าด้วยเหตุผลบางประการเราต้องการประเมินฟังก์ชัน y = 5*x + 13 ในแฟชั่น TensorFlow
ในรหัส Python แบบธรรมดาจะมีลักษณะดังนี้:
x = -2.0 y = 5*x + 13 print y ซึ่งทำให้เราได้ผลลัพธ์เป็น 3.0 ในกรณีนี้
ตอนนี้เราจะแปลงนิพจน์ข้างต้นเป็นเงื่อนไข TensorFlow
ค่าคงที่
ใน TensorFlow ค่าคงที่ถูกสร้างขึ้นโดยใช้ค่าคงที่ของฟังก์ชันซึ่งมีลายเซ็น constant(value, dtype=None, shape=None, name='Const', verify_shape=False) โดยที่ value คือค่าคงที่จริงซึ่งจะใช้ในการคำนวณเพิ่มเติม, dtype คือพารามิเตอร์ชนิดข้อมูล (เช่น float32 / 64, int8 / 16 เป็นต้น), shape เป็นมิติข้อมูลเสริม name เป็นชื่อทางเลือกสำหรับเทนเซอร์และพารามิเตอร์สุดท้ายคือบูลีนซึ่งระบุการตรวจสอบรูปร่างของค่า
หากคุณต้องการค่าคงที่ที่มีค่าเฉพาะในแบบจำลองการฝึกของคุณให้ใช้ constant สามารถใช้วัตถุดังตัวอย่างต่อไปนี้:
z = tf.constant(5.2, name='x', dtype=tf.float32) ตัวแปร
ตัวแปรใน TensorFlow คือบัฟเฟอร์ในหน่วยความจำที่มีเทนเซอร์ซึ่งต้องได้รับการเตรียมใช้งานอย่างชัดเจนและใช้ในกราฟเพื่อรักษาสถานะระหว่างเซสชัน เพียงแค่เรียกตัวสร้างตัวแปรจะถูกเพิ่มลงในกราฟการคำนวณ
ตัวแปรมีประโยชน์อย่างยิ่งเมื่อคุณเริ่มต้นด้วยแบบจำลองการฝึกอบรมและใช้เพื่อเก็บและอัปเดตพารามิเตอร์ ค่าเริ่มต้นที่ส่งผ่านเป็นอาร์กิวเมนต์ของตัวสร้างแทนค่าเทนเซอร์หรืออ็อบเจ็กต์ซึ่งสามารถแปลงหรือส่งคืนเป็นเทนเซอร์ได้ นั่นหมายความว่าหากเราต้องการเติมตัวแปรด้วยค่าที่กำหนดไว้ล่วงหน้าหรือสุ่มเพื่อใช้ในภายหลังในขั้นตอนการฝึกอบรมและอัปเดตการวนซ้ำเราสามารถกำหนดตัวแปรได้ดังนี้:
k = tf.Variable(tf.zeros([1]), name='k') อีกวิธีหนึ่งในการใช้ตัวแปรใน TensorFlow คือการคำนวณโดยที่ตัวแปรนั้นไม่สามารถฝึกได้และสามารถกำหนดได้ด้วยวิธีต่อไปนี้:
k = tf.Variable(tf.add(a, b), trainable=False) เซสชัน
ในการประเมินโหนดจริงเราต้องเรียกใช้กราฟการคำนวณภายในเซสชัน
เซสชันจะห่อหุ้มการควบคุมและสถานะของรันไทม์ TensorFlow เซสชันที่ไม่มีพารามิเตอร์จะใช้กราฟเริ่มต้นที่สร้างขึ้นในเซสชันปัจจุบันมิฉะนั้นคลาสเซสชันจะยอมรับพารามิเตอร์กราฟซึ่งใช้ในเซสชันนั้นเพื่อดำเนินการ
ด้านล่างนี้เป็นข้อมูลโค้ดสั้น ๆ ที่แสดงให้เห็นว่าคำศัพท์ที่กำหนดไว้ข้างต้นสามารถใช้ใน TensorFlow เพื่อคำนวณฟังก์ชันเชิงเส้นอย่างง่ายได้อย่างไร
import tensorflow as tf x = tf.constant(-2.0, name='x', dtype=tf.float32) a = tf.constant(5.0, name='a', dtype=tf.float32) b = tf.constant(13.0, name='b', dtype=tf.float32) y = tf.Variable(tf.add(tf.multiply(a, x), b)) init = tf.global_variables_initializer() with tf.Session() as session: session.run(init) print session.run(y) การใช้ TensorFlow: การกำหนดกราฟเชิงคำนวณ
ข้อดีของการทำงานกับกราฟกระแสข้อมูลคือโมเดลการดำเนินการจะแยกออกจากการดำเนินการ (บน CPU, GPU หรือชุดค่าผสมบางอย่าง) ซึ่งเมื่อใช้งานแล้วซอฟต์แวร์ใน TensorFlow สามารถใช้กับ CPU หรือ GPU ได้ซึ่งความซับซ้อนทั้งหมดที่เกี่ยวข้องกับโค้ด การดำเนินการถูกซ่อนอยู่
กราฟการคำนวณสามารถสร้างขึ้นในกระบวนการใช้ไลบรารี TensorFlow โดยไม่ต้องสร้างอินสแตนซ์อย่างชัดเจน กราฟ วัตถุ
ออบเจ็กต์กราฟใน TensorFlow สามารถสร้างขึ้นได้จากบรรทัดโค้ดง่ายๆเช่น c = tf.add(a, b) สิ่งนี้จะสร้างโหนดการดำเนินการที่รับสองเทนเซอร์ a และ b ที่ให้ผลรวม c เป็นเอาต์พุต
กราฟการคำนวณเป็นกระบวนการในตัวที่ใช้ไลบรารีโดยไม่จำเป็นต้องเรียกไฟล์ กราฟ วัตถุโดยตรง ออบเจ็กต์กราฟใน TensorFlow ซึ่งมีชุดของการดำเนินการและเทนเซอร์เป็นหน่วยของข้อมูลถูกใช้ระหว่างการดำเนินการซึ่งอนุญาตให้ใช้กระบวนการเดียวกันและมีกราฟมากกว่าหนึ่งกราฟซึ่งแต่ละกราฟจะถูกกำหนดให้กับเซสชันที่แตกต่างกัน ตัวอย่างเช่นบรรทัดรหัสง่ายๆ c = tf.add(a, b) จะสร้างโหนดการดำเนินการที่รับสองเทนเซอร์ a และ b เป็นอินพุตและสร้างผลรวม c เป็นเอาต์พุต
TensorFlow ยังมีกลไกฟีดสำหรับการแพทเทนเซอร์กับการดำเนินการใด ๆ ในกราฟโดยฟีดจะแทนที่เอาต์พุตของการดำเนินการด้วยค่าเทนเซอร์ ข้อมูลฟีดจะถูกส่งเป็นอาร์กิวเมนต์ใน run() การเรียกใช้ฟังก์ชัน
ตัวยึดตำแหน่งเป็นวิธีการของ TensorFlow ในการอนุญาตให้นักพัฒนาฉีดข้อมูลลงในกราฟการคำนวณผ่านตัวยึดตำแหน่งที่ถูกผูกไว้ภายในนิพจน์ ลายเซ็นของตัวยึดคือ:
placeholder(dtype, shape=None, name=None) โดยที่ dtype เป็นชนิดขององค์ประกอบในเทนเซอร์และสามารถระบุทั้งรูปร่างของเทนเซอร์ที่จะป้อนและชื่อสำหรับการดำเนินการ
หากไม่ผ่านรูปร่างเทนเซอร์นี้สามารถป้อนด้วยรูปทรงใดก็ได้ ข้อสังเกตที่สำคัญคือตัวยึดตำแหน่งเทนเซอร์จะต้องถูกป้อนด้วยข้อมูลมิฉะนั้นเมื่อดำเนินการเซสชันและหากส่วนนั้นหายไปตัวยึดจะสร้างข้อผิดพลาดด้วยโครงสร้างต่อไปนี้
InvalidArgumentError (see above for traceback): You must feed a value for placeholder tensor 'y' with dtype float ข้อดีของตัวยึดตำแหน่งคืออนุญาตให้นักพัฒนาสร้างการดำเนินงานและกราฟการคำนวณโดยทั่วไปโดยไม่จำเป็นต้องให้ข้อมูลล่วงหน้าสำหรับสิ่งนั้นและสามารถเพิ่มข้อมูลในรันไทม์จากแหล่งภายนอกได้
ลองใช้โจทย์ง่ายๆในการคูณจำนวนเต็มสองจำนวน x และ y ในรูปแบบ TensorFlow ซึ่งจะใช้ตัวยึดตำแหน่งร่วมกับกลไกฟีดผ่านเซสชัน run วิธี.
import tensorflow as tf x = tf.placeholder(tf.float32, name='x') y = tf.placeholder(tf.float32, name='y') z = tf.multiply(x, y, name='z') with tf.Session() as session: print session.run(z, feed_dict={x: 2.1, y: 3.0}) การแสดงกราฟการคำนวณด้วย TensorBoard
TensorBoard เป็นเครื่องมือแสดงภาพสำหรับวิเคราะห์กราฟกระแสข้อมูล ซึ่งจะมีประโยชน์ในการทำความเข้าใจโมเดลแมชชีนเลิร์นนิงให้ดีขึ้น
ด้วย TensorBoard คุณจะได้รับข้อมูลเชิงลึกเกี่ยวกับสถิติประเภทต่างๆเกี่ยวกับพารามิเตอร์และรายละเอียดเกี่ยวกับส่วนต่างๆของกราฟการคำนวณโดยทั่วไป ไม่ใช่เรื่องผิดปกติที่โครงข่ายประสาทส่วนลึกจะมีโหนดจำนวนมาก TensorBoard ช่วยให้นักพัฒนาได้รับข้อมูลเชิงลึกเกี่ยวกับแต่ละโหนดและวิธีการคำนวณผ่านรันไทม์ TensorFlow
ตอนนี้กลับไปที่ตัวอย่างของเราตั้งแต่เริ่มต้นของบทช่วยสอน TensorFlow ที่เรากำหนดฟังก์ชันเชิงเส้นด้วยรูปแบบ y = a*x + b
เพื่อบันทึกเหตุการณ์จากเซสชันซึ่งสามารถใช้ในภายหลังได้ใน TensorBoard TensorFlow จะจัดเตรียม FileWriter ชั้นเรียน สามารถใช้เพื่อสร้างไฟล์เหตุการณ์สำหรับจัดเก็บ สรุป และ เหตุการณ์ โดยที่ตัวสร้างยอมรับพารามิเตอร์หกตัวและดูเหมือนว่า:
__init__(logdir, graph=None, max_queue=10, flush_secs=120, graph_def=None, filename_suffix=None) โดยที่พารามิเตอร์ logdir จำเป็นและอื่น ๆ มีค่าดีฟอลต์ พารามิเตอร์กราฟจะถูกส่งผ่านจากวัตถุเซสชันที่สร้างขึ้นในโปรแกรมการฝึกอบรม โค้ดตัวอย่างทั้งหมดมีลักษณะดังนี้:
import tensorflow as tf x = tf.constant(-2.0, name='x', dtype=tf.float32) a = tf.constant(5.0, name='a', dtype=tf.float32) b = tf.constant(13.0, name='b', dtype=tf.float32) y = tf.Variable(tf.add(tf.multiply(a, x), b)) init = tf.global_variables_initializer() with tf.Session() as session: merged = tf.summary.merge_all() // new writer = tf.summary.FileWriter('logs', session.graph) // new session.run(init) print session.run(y) เราเพิ่มบรรทัดใหม่เพียงสองบรรทัด เรารวมบทสรุปทั้งหมดที่รวบรวมไว้ในกราฟเริ่มต้นและ FileWriter ใช้เพื่อถ่ายโอนเหตุการณ์ไปยังไฟล์ตามที่เราอธิบายไว้ข้างต้นตามลำดับ
หลังจากรันโปรแกรมเรามีไฟล์ในบันทึกไดเร็กทอรีและขั้นตอนสุดท้ายคือการเรียกใช้ tensorboard:
tensorboard --logdir logs/ ตอนนี้ TensorBoard เริ่มต้นและทำงานบนพอร์ตเริ่มต้น 6006 หลังจากเปิด http://localhost:6006 และคลิกที่รายการเมนูกราฟ (อยู่ที่ด้านบนสุดของหน้า) คุณจะสามารถเห็นกราฟดังภาพด้านล่างนี้:
TensorBoard ทำเครื่องหมายค่าคงที่และสัญลักษณ์เฉพาะโหนดสรุปซึ่งอธิบายไว้ด้านล่าง
คณิตศาสตร์กับ TensorFlow
Tensors เป็นโครงสร้างข้อมูลพื้นฐานใน TensorFlow และแสดงขอบเชื่อมต่อในกราฟกระแสข้อมูล
เทนเซอร์เพียงแค่ระบุอาร์เรย์หรือรายการหลายมิติ โครงสร้างเทนเซอร์สามารถระบุได้ด้วยพารามิเตอร์สามตัว ได้แก่ อันดับรูปร่างและประเภท
- อันดับ: ระบุจำนวนมิติของเทนเซอร์ อันดับเรียกว่าลำดับหรือ n มิติของเทนเซอร์โดยตัวอย่างเช่นอันดับ 1 เทนเซอร์เป็นเวกเตอร์หรืออันดับ 2 เทนเซอร์เป็นเมทริกซ์
- รูปร่าง: รูปร่างของเทนเซอร์คือจำนวนแถวและคอลัมน์ที่มี
- ประเภท: ประเภทข้อมูลที่กำหนดให้กับองค์ประกอบเทนเซอร์
ในการสร้างเทนเซอร์ใน TensorFlow เราสามารถสร้างอาร์เรย์ n มิติ สิ่งนี้สามารถทำได้อย่างง่ายดายโดยใช้ไลบรารี NumPy หรือโดยการแปลงอาร์เรย์ n มิติของ Python เป็นเทนเซอร์ TensorFlow
ในการสร้างเทนเซอร์ 1 มิติเราจะใช้อาร์เรย์ NumPy ซึ่งเราจะสร้างโดยส่งผ่านรายการ Python ในตัว
import numpy as np tensor_1d = np.array([1.45, -1, 0.2, 102.1]) การทำงานกับอาร์เรย์ประเภทนี้คล้ายกับการทำงานกับรายการ Python ในตัว ความแตกต่างที่สำคัญคืออาร์เรย์ NumPy ยังมีคุณสมบัติเพิ่มเติมบางอย่างเช่นมิติรูปร่างและประเภท
> > print tensor1d [ 1.45 -1. 0.2 102.1 ] > > print tensor1d[0] 1.45 > > print tensor1d[2] 0.2 > > print tensor1d.ndim 1 > > print tensor1d.shape (4,) > > print tensor1d.dtype float64 อาร์เรย์ NumPy สามารถแปลงเป็นเทนเซอร์ TensorFlow ได้อย่างง่ายดายด้วยฟังก์ชันเสริม Convert_to_tensor ซึ่งช่วยให้นักพัฒนาแปลงวัตถุ Python เป็นวัตถุเทนเซอร์ ฟังก์ชันนี้ยอมรับวัตถุเทนเซอร์อาร์เรย์ NumPy รายการ Python และสเกลาร์ Python
tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64) ตอนนี้ถ้าเราผูกเทนเซอร์ของเรากับเซสชัน TensorFlow เราจะสามารถเห็นผลลัพธ์ของการแปลงของเราได้
tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64) with tf.Session() as session: print session.run(tensor) print session.run(tensor[0]) print session.run(tensor[1]) เอาท์พุต:
[ 1.45 -1. 0.2 102.1 ] 1.45 -1.0 เราสามารถสร้างเทนเซอร์ 2 มิติหรือเมทริกซ์ได้ในลักษณะเดียวกัน:
tensor_2d = np.array(np.random.rand(4, 4), dtype='float32') tensor_2d_1 = np.array(np.random.rand(4, 4), dtype='float32') tensor_2d_2 = np.array(np.random.rand(4, 4), dtype='float32') m1 = tf.convert_to_tensor(tensor_2d) m2 = tf.convert_to_tensor(tensor_2d_1) m3 = tf.convert_to_tensor(tensor_2d_2) mat_product = tf.matmul(m1, m2) mat_sum = tf.add(m2, m3) mat_det = tf.matrix_determinant(m3) with tf.Session() as session: print session.run(mat_product) print session.run(mat_sum) print session.run(mat_det) การดำเนินงาน Tensor
ในตัวอย่างด้านบนเราแนะนำการดำเนินการ TensorFlow บางส่วนบนเวกเตอร์และเมทริกซ์ การดำเนินการจะทำการคำนวณบางอย่างกับเทนเซอร์ การคำนวณเหล่านี้แสดงไว้ในตารางด้านล่าง
| ตัวดำเนินการ TensorFlow | คำอธิบาย |
|---|---|
| tf.add | x + y |
| tf.subtract | x-y |
| tf. ทวีคูณ | x * y |
| tf.div | x / y |
| tf.mod | x% y |
| tf.abs | | x | |
| tf.negative | -x |
| tf.sign | เครื่องหมาย (x) |
| tf.square | x * x |
| tf.round | รอบ (x) |
| tf.sqrt | sqrt (x) |
| tf.pow | x ^ y |
| tf.exp | จ ^ x |
| tf.log | บันทึก (x) |
| tf.maximum | สูงสุด (x, y) |
| tf.minimum | นาที (x, y) |
| tf.cos | cos (x) |
| tf.sin | บาป (x) |
การดำเนินการ TensorFlow ที่แสดงในตารางด้านบนทำงานกับวัตถุเทนเซอร์และดำเนินการอย่างชาญฉลาด ดังนั้นหากคุณต้องการคำนวณโคไซน์สำหรับเวกเตอร์ x การดำเนินการ TensorFlow จะทำการคำนวณสำหรับแต่ละองค์ประกอบในเทนเซอร์ที่ส่งผ่าน
tensor_1d = np.array([0, 0, 0]) tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64) with tf.Session() as session: print session.run(tf.cos(tensor)) เอาท์พุต:
[ 1. 1. 1.] การดำเนินการเมทริกซ์
การดำเนินการเมทริกซ์มีความสำคัญมากสำหรับโมเดลการเรียนรู้ของเครื่องเช่นการถดถอยเชิงเส้นเนื่องจากมักใช้ในรูปแบบเหล่านี้ TensorFlow รองรับการดำเนินการเมทริกซ์ที่พบบ่อยที่สุดเช่น การคูณ , การขนย้าย , การลงทุน การคำนวณ ดีเทอร์มิแนนต์ , การแก้ สมการเชิงเส้น และ อื่น ๆ อีกมากมาย .
ต่อไปเราจะอธิบายการดำเนินการเมทริกซ์บางส่วน พวกเขามักจะมีความสำคัญเมื่อพูดถึงโมเดลการเรียนรู้ของเครื่องเช่นการถดถอยเชิงเส้น มาเขียนโค้ดที่จะดำเนินการเมทริกซ์พื้นฐานเช่นการคูณการรับ ทรานสโพส การหาดีเทอร์มิแนนต์การคูณโซลและอื่น ๆ อีกมากมาย
ด้านล่างนี้เป็นตัวอย่างพื้นฐานของการเรียกใช้การดำเนินการเหล่านี้
import tensorflow as tf import numpy as np def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) m1 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m2 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m3 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m4 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m5 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m_tranpose = tf.transpose(m1) m_mul = tf.matmul(m1, m2) m_det = tf.matrix_determinant(m3) m_inv = tf.matrix_inverse(m4) m_solve = tf.matrix_solve(m5, [[1], [1], [1], [1]]) with tf.Session() as session: print session.run(m_tranpose) print session.run(m_mul) print session.run(m_inv) print session.run(m_det) print session.run(m_solve) การแปลงข้อมูล
การลด
TensorFlow รองรับการลดประเภทต่างๆ การลดคือการดำเนินการที่ลบหนึ่งมิติหรือมากกว่านั้นออกจากเทนเซอร์โดยการดำเนินการบางอย่างในมิติเหล่านั้น รายการการลดที่รองรับสำหรับ TensorFlow เวอร์ชันปัจจุบันมีอยู่ที่นี่ เราจะนำเสนอบางส่วนในตัวอย่างด้านล่าง
import tensorflow as tf import numpy as np def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) x = convert( np.array( [ (1, 2, 3), (4, 5, 6), (7, 8, 9) ]), tf.int32) bool_tensor = convert([(True, False, True), (False, False, True), (True, False, False)], tf.bool) red_sum_0 = tf.reduce_sum(x) red_sum = tf.reduce_sum(x, axis=1) red_prod_0 = tf.reduce_prod(x) red_prod = tf.reduce_prod(x, axis=1) red_min_0 = tf.reduce_min(x) red_min = tf.reduce_min(x, axis=1) red_max_0 = tf.reduce_max(x) red_max = tf.reduce_max(x, axis=1) red_mean_0 = tf.reduce_mean(x) red_mean = tf.reduce_mean(x, axis=1) red_bool_all_0 = tf.reduce_all(bool_tensor) red_bool_all = tf.reduce_all(bool_tensor, axis=1) red_bool_any_0 = tf.reduce_any(bool_tensor) red_bool_any = tf.reduce_any(bool_tensor, axis=1) with tf.Session() as session: print 'Reduce sum without passed axis parameter: ', session.run(red_sum_0) print 'Reduce sum with passed axis=1: ', session.run(red_sum) print 'Reduce product without passed axis parameter: ', session.run(red_prod_0) print 'Reduce product with passed axis=1: ', session.run(red_prod) print 'Reduce min without passed axis parameter: ', session.run(red_min_0) print 'Reduce min with passed axis=1: ', session.run(red_min) print 'Reduce max without passed axis parameter: ', session.run(red_max_0) print 'Reduce max with passed axis=1: ', session.run(red_max) print 'Reduce mean without passed axis parameter: ', session.run(red_mean_0) print 'Reduce mean with passed axis=1: ', session.run(red_mean) print 'Reduce bool all without passed axis parameter: ', session.run(red_bool_all_0) print 'Reduce bool all with passed axis=1: ', session.run(red_bool_all) print 'Reduce bool any without passed axis parameter: ', session.run(red_bool_any_0) print 'Reduce bool any with passed axis=1: ', session.run(red_bool_any) เอาท์พุต:
Reduce sum without passed axis parameter: 45 Reduce sum with passed axis=1: [ 6 15 24] Reduce product without passed axis parameter: 362880 Reduce product with passed axis=1: [ 6 120 504] Reduce min without passed axis parameter: 1 Reduce min with passed axis=1: [1 4 7] Reduce max without passed axis parameter: 9 Reduce max with passed axis=1: [3 6 9] Reduce mean without passed axis parameter: 5 Reduce mean with passed axis=1: [2 5 8] Reduce bool all without passed axis parameter: False Reduce bool all with passed axis=1: [False False False] Reduce bool any without passed axis parameter: True Reduce bool any with passed axis=1: [ True True True] พารามิเตอร์แรกของตัวดำเนินการลดคือเทนเซอร์ที่เราต้องการลด พารามิเตอร์ที่สองคือดัชนีของมิติที่เราต้องการทำการลด พารามิเตอร์นั้นเป็นทางเลือกและหากไม่ผ่านการลดจะดำเนินการในทุกมิติ
เราสามารถดูที่ไฟล์ ลดราคา การดำเนินการ. เราผ่านเทนเซอร์ 2 มิติและต้องการลดขนาดตามมิติที่ 1
ในกรณีของเราผลรวมที่ได้จะเป็น:
[1 + 2 + 3 = 6, 4 + 5 + 6 = 15, 7 + 8 + 9 = 24] ถ้าเราผ่านมิติ 0 ผลลัพธ์จะเป็น:
[1 + 4 + 7 = 12, 2 + 5 + 8 = 15, 3 + 6 + 9 = 18] หากเราไม่ส่งผ่านแกนใด ๆ ผลลัพธ์จะเป็นเพียงผลรวมโดยรวมของ:
1 + 4 + 7 = 12, 2 + 5 + 8 = 15, 3 + 6 + 9 = 45 ฟังก์ชันการลดทั้งหมดมีอินเทอร์เฟซที่คล้ายกันและแสดงอยู่ใน TensorFlow เอกสารการลด .
การแบ่งกลุ่ม
การแบ่งกลุ่มเป็นกระบวนการที่มิติใดมิติหนึ่งเป็นกระบวนการของการแม็ปมิติลงบนดัชนีเซ็กเมนต์ที่จัดเตรียมไว้และองค์ประกอบที่เป็นผลลัพธ์จะถูกกำหนดโดยแถวดัชนี
การแบ่งกลุ่มเป็นการจัดกลุ่มองค์ประกอบภายใต้ดัชนีซ้ำ ๆ กันดังนั้นในกรณีของเราเราได้แบ่งกลุ่มรหัส [0, 0, 1, 2, 2] นำไปใช้กับเทนเซอร์ tens1 ซึ่งหมายความว่าอาร์เรย์แรกและอาร์เรย์ที่สองจะถูกเปลี่ยนหลังจากการดำเนินการแบ่งส่วน (ในกรณีของเรา summation) และจะได้รับอาร์เรย์ใหม่ซึ่งดูเหมือน (2, 8, 1, 0) = (2+0, 5+3, 3-2, -5+5) องค์ประกอบที่สามในเทนเซอร์ tens1 ไม่ถูกแตะต้องเนื่องจากไม่ได้ถูกจัดกลุ่มในดัชนีซ้ำใด ๆ และสองอาร์เรย์สุดท้ายจะถูกสรุปในลักษณะเดียวกับกรณีของกลุ่มแรก นอกเหนือจากการสรุปแล้ว TensorFlow ยังรองรับ ผลิตภัณฑ์ , ค่าเฉลี่ย , สูงสุด และ นาที .
import tensorflow as tf import numpy as np def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) seg_ids = tf.constant([0, 0, 1, 2, 2]) tens1 = convert(np.array([(2, 5, 3, -5), (0, 3, -2, 5), (4, 3, 5, 3), (6, 1, 4, 0), (6, 1, 4, 0)]), tf.int32) tens2 = convert(np.array([1, 2, 3, 4, 5]), tf.int32) seg_sum = tf.segment_sum(tens1, seg_ids) seg_sum_1 = tf.segment_sum(tens2, seg_ids) with tf.Session() as session: print 'Segmentation sum tens1: ', session.run(seg_sum) print 'Segmentation sum tens2: ', session.run(seg_sum_1) Segmentation sum tens1: [[ 2 8 1 0] [ 4 3 5 3] [12 2 8 0]] Segmentation sum tens2: [3 3 9] ยูทิลิตี้ลำดับ
ยูทิลิตี้ลำดับรวมถึงวิธีการต่างๆเช่น:
- อาร์กมิน ฟังก์ชันซึ่งส่งคืนดัชนีด้วยค่าต่ำสุดในแกนของเทนเซอร์อินพุต
- argmax ฟังก์ชันซึ่งส่งคืนดัชนีที่มีค่าสูงสุดในแกนของเทนเซอร์อินพุต
- setdiff ซึ่งคำนวณความแตกต่างระหว่างรายการตัวเลขหรือสตริงสองรายการ
- ที่ไหน ฟังก์ชันซึ่งจะส่งคืนองค์ประกอบจากสององค์ประกอบที่ส่งผ่าน x หรือ y ซึ่งขึ้นอยู่กับเงื่อนไขที่ส่งผ่านหรือ
- ไม่เหมือนใคร ฟังก์ชันซึ่งจะส่งคืนองค์ประกอบที่ไม่ซ้ำกันในเทนเซอร์ 1 มิติ
เราแสดงตัวอย่างการดำเนินการบางส่วนด้านล่าง:
import numpy as np import tensorflow as tf def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) x = convert(np.array([ [2, 2, 1, 3], [4, 5, 6, -1], [0, 1, 1, -2], [6, 2, 3, 0] ])) y = convert(np.array([1, 2, 5, 3, 7])) z = convert(np.array([1, 0, 4, 6, 2])) arg_min = tf.argmin(x, 1) arg_max = tf.argmax(x, 1) unique = tf.unique(y) diff = tf.setdiff1d(y, z) with tf.Session() as session: print 'Argmin = ', session.run(arg_min) print 'Argmax = ', session.run(arg_max) print 'Unique_values = ', session.run(unique)[0] print 'Unique_idx = ', session.run(unique)[1] print 'Setdiff_values = ', session.run(diff)[0] print 'Setdiff_idx = ', session.run(diff)[1] print session.run(diff)[1] เอาท์พุต:
Argmin = [2 3 3 3] Argmax = [3 2 1 0] Unique_values = [ 1. 2. 5. 3. 7.] Unique_idx = [0 1 2 3 4] Setdiff_values = [ 5. 3. 7.] Setdiff_idx = [2 3 4] การเรียนรู้ของเครื่องด้วย TensorFlow
ในส่วนนี้เราจะนำเสนอกรณีการใช้งานแมชชีนเลิร์นนิงกับ TensorFlow ตัวอย่างแรกจะเป็นอัลกอริทึมสำหรับการจำแนกข้อมูลด้วยไฟล์ kNN วิธีการและวิธีที่สองจะใช้ไฟล์ อัลกอริธึมการถดถอยเชิงเส้น .
kNN
อัลกอริทึมแรกคือ k-Nearest Neighbours (kNN) เป็นอัลกอริทึมการเรียนรู้ภายใต้การดูแลซึ่งใช้เมตริกระยะทางเช่นระยะทางแบบยุคลิดเพื่อจัดประเภทข้อมูลเทียบกับการฝึกอบรม เป็นหนึ่งในอัลกอริทึมที่ง่ายที่สุด แต่ยังคงมีประสิทธิภาพมากสำหรับการจำแนกประเภทข้อมูล ข้อดีของอัลกอริทึมนี้:
- ให้ความแม่นยำสูงเมื่อแบบจำลองการฝึกอบรมมีขนาดใหญ่พอและ
- โดยปกติแล้วไม่ได้มีความอ่อนไหวต่อค่าผิดปกติและเราไม่จำเป็นต้องมีข้อสันนิษฐานเกี่ยวกับข้อมูล
จุดด้อยของอัลกอริทึมนี้:
- ราคาแพงในการคำนวณและ
- ต้องใช้หน่วยความจำจำนวนมากซึ่งจำเป็นต้องเพิ่มข้อมูลประเภทใหม่ให้กับอินสแตนซ์การฝึกเริ่มต้นทั้งหมด
ระยะทางที่เราจะใช้ในตัวอย่างโค้ดนี้คือ Euclidean ซึ่งกำหนดระยะห่างระหว่างจุดสองจุดดังนี้:
ในสูตรนี้ n คือจำนวนมิติของช่องว่าง x คือเวกเตอร์ของข้อมูลการฝึกอบรมและ y เป็นจุดข้อมูลใหม่ที่เราต้องการจัดประเภท
import os import numpy as np import tensorflow as tf ccf_train_data = 'train_dataset.csv' ccf_test_data = 'test_dataset.csv' dataset_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../datasets')) ccf_train_filepath = os.path.join(dataset_dir, ccf_train_data) ccf_test_filepath = os.path.join(dataset_dir, ccf_test_data) def load_data(filepath): from numpy import genfromtxt csv_data = genfromtxt(filepath, delimiter=',', skip_header=1) data = [] labels = [] for d in csv_data: data.append(d[:-1]) labels.append(d[-1]) return np.array(data), np.array(labels) train_dataset, train_labels = load_data(ccf_train_filepath) test_dataset, test_labels = load_data(ccf_test_filepath) train_pl = tf.placeholder('float', [None, 28]) test_pl = tf.placeholder('float', [28]) knn_prediction = tf.reduce_sum(tf.abs(tf.add(train_pl, tf.negative(test_pl))), axis=1) pred = tf.argmin(knn_prediction, 0) with tf.Session() as tf_session: missed = 0 for i in xrange(len(test_dataset)): knn_index = tf_session.run(pred, feed_dict={train_pl: train_dataset, test_pl: test_dataset[i]}) print 'Predicted class {} -- True class {}'.format(train_labels[knn_index], test_labels[i]) if train_labels[knn_index] != test_labels[i]: missed += 1 tf.summary.FileWriter('../samples/article/logs', tf_session.graph) print 'Missed: {} -- Total: {}'.format(missed, len(test_dataset)) ชุดข้อมูลที่เราใช้ในตัวอย่างข้างต้นเป็นชุดข้อมูลที่สามารถพบได้ในไฟล์ ชุดข้อมูล Kaggle มาตรา. เราใช้ไฟล์ หนึ่ง ซึ่งประกอบด้วยธุรกรรมที่ทำโดยบัตรเครดิตของผู้ถือบัตรในยุโรป เรากำลังใช้ข้อมูลโดยไม่ต้องทำความสะอาดหรือกรองใด ๆ และตามคำอธิบายใน Kaggle สำหรับชุดข้อมูลนี้มีความไม่สมดุลอย่างมาก ชุดข้อมูลประกอบด้วยตัวแปร 31 ตัว: Time, V1, …, V28, Amount และ Class ในตัวอย่างโค้ดนี้เราใช้เฉพาะ V1, …, V28 และ Class การทำธุรกรรมป้ายกำกับระดับที่เป็นการฉ้อโกงกับ 1 และธุรกรรมที่ไม่ใช่ด้วย 0
ตัวอย่างโค้ดส่วนใหญ่ประกอบด้วยสิ่งที่เราอธิบายไว้ในส่วนก่อนหน้ายกเว้นที่เราแนะนำฟังก์ชันสำหรับการโหลดชุดข้อมูล ฟังก์ชั่น load_data(filepath) จะใช้ไฟล์ CSV เป็นอาร์กิวเมนต์และจะส่งคืนทูเปิลพร้อมข้อมูลและป้ายกำกับที่กำหนดไว้ใน CSV
ด้านล่างของฟังก์ชันนั้นเราได้กำหนดตัวยึดตำแหน่งสำหรับการทดสอบและข้อมูลที่ผ่านการฝึกอบรมแล้ว ข้อมูลที่ผ่านการฝึกอบรมจะใช้ในแบบจำลองการคาดคะเนเพื่อแก้ไขป้ายกำกับสำหรับข้อมูลอินพุตที่ต้องจัดประเภท ในกรณีของเรา kNN ใช้ Euclidian distance เพื่อให้ได้ป้ายที่ใกล้ที่สุด
อัตราความผิดพลาดสามารถคำนวณได้โดยการหารอย่างง่ายด้วยตัวเลขเมื่อตัวแยกประเภทพลาดไปโดยจำนวนตัวอย่างทั้งหมดซึ่งในกรณีของเราสำหรับชุดข้อมูลนี้คือ 0.2 (นั่นคือตัวจำแนกให้ป้ายข้อมูลที่ไม่ถูกต้องสำหรับข้อมูลทดสอบ 20%)
การถดถอยเชิงเส้น
อัลกอริธึมการถดถอยเชิงเส้นจะค้นหาความสัมพันธ์เชิงเส้นระหว่างสองตัวแปร หากเราติดป้ายกำกับตัวแปรตามเป็น y และตัวแปรอิสระเป็น x แสดงว่าเรากำลังพยายามประมาณค่าพารามิเตอร์ของฟังก์ชัน y = Wx + b
การถดถอยเชิงเส้นเป็นขั้นตอนวิธีที่ใช้กันอย่างแพร่หลายในสาขาวิทยาศาสตร์ประยุกต์ อัลกอริทึมนี้ช่วยให้สามารถเพิ่มแนวคิดสำคัญสองประการของการเรียนรู้ของเครื่อง: ฟังก์ชันต้นทุน และ วิธีการไล่ระดับสี สำหรับการหาค่าต่ำสุดของฟังก์ชัน
อัลกอริธึมแมชชีนเลิร์นนิงที่ใช้วิธีนี้จะต้องทำนายค่าของ y เป็นฟังก์ชันของ x โดยที่อัลกอริธึมการถดถอยเชิงเส้นจะกำหนดค่า W และ b ซึ่งเป็นสิ่งที่ไม่ทราบจริงและถูกกำหนดในกระบวนการฝึกอบรม มีการเลือกฟังก์ชันต้นทุนและโดยปกติจะใช้ข้อผิดพลาดกำลังสองเฉลี่ยโดยที่การไล่ระดับสีเป็นอัลกอริทึมการเพิ่มประสิทธิภาพที่ใช้เพื่อค้นหาฟังก์ชันต้นทุนขั้นต่ำในพื้นที่
วิธีการไล่ระดับสีเป็นเพียงฟังก์ชันขั้นต่ำเท่านั้น แต่สามารถใช้ในการค้นหาค่าต่ำสุดทั่วโลกโดยการสุ่มเลือกจุดเริ่มต้นใหม่เมื่อพบค่าต่ำสุดในเครื่องและทำซ้ำขั้นตอนนี้หลาย ๆ ครั้ง หากจำนวนขั้นต่ำของฟังก์ชั่นมี จำกัด และมีจำนวนครั้งที่สูงมากก็มีโอกาสดีที่จะมีการตรวจพบขั้นต่ำทั่วโลกในบางจุด รายละเอียดเพิ่มเติมเกี่ยวกับเทคนิคนี้เราจะปล่อยให้ บทความ ซึ่งเราได้กล่าวถึงในส่วนการแนะนำ
import tensorflow as tf import numpy as np test_data_size = 2000 iterations = 10000 learn_rate = 0.005 def generate_test_values(): train_x = [] train_y = [] for _ in xrange(test_data_size): x1 = np.random.rand() x2 = np.random.rand() x3 = np.random.rand() y_f = 2 * x1 + 3 * x2 + 7 * x3 + 4 train_x.append([x1, x2, x3]) train_y.append(y_f) return np.array(train_x), np.transpose([train_y]) x = tf.placeholder(tf.float32, [None, 3], name='x') W = tf.Variable(tf.zeros([3, 1]), name='W') b = tf.Variable(tf.zeros([1]), name='b') y = tf.placeholder(tf.float32, [None, 1]) model = tf.add(tf.matmul(x, W), b) cost = tf.reduce_mean(tf.square(y - model)) train = tf.train.GradientDescentOptimizer(learn_rate).minimize(cost) train_dataset, train_values = generate_test_values() init = tf.global_variables_initializer() with tf.Session() as session: session.run(init) for _ in xrange(iterations): session.run(train, feed_dict={ x: train_dataset, y: train_values }) print 'cost = {}'.format(session.run(cost, feed_dict={ x: train_dataset, y: train_values })) print 'W = {}'.format(session.run(W)) print 'b = {}'.format(session.run(b)) เอาท์พุต:
cost = 3.1083032809e-05 W = [[ 1.99049103] [ 2.9887135 ] [ 6.98754263]] b = [ 4.01742554] ในตัวอย่างข้างต้นเรามีตัวแปรใหม่สองตัวซึ่งเราเรียกว่า cost และ train. ด้วยตัวแปรทั้งสองนี้เราได้กำหนดเครื่องมือเพิ่มประสิทธิภาพที่เราต้องการใช้ในรูปแบบการฝึกอบรมของเราและฟังก์ชันที่เราต้องการย่อเล็กสุด
ในตอนท้ายพารามิเตอร์เอาต์พุตของ W และ b ควรจะเหมือนกับที่กำหนดไว้ใน generate_test_values ฟังก์ชัน ในบรรทัดที่ 17 เราได้กำหนดฟังก์ชันที่เราใช้สร้างจุดข้อมูลเชิงเส้นเพื่อฝึกโดยที่ w1=2, w2=3, w3=7 และ b=4. การถดถอยเชิงเส้นจากตัวอย่างข้างต้นเป็นตัวแปรหลายตัวแปรที่ใช้ตัวแปรอิสระมากกว่าหนึ่งตัวแปร
สรุป
ดังที่คุณเห็นจากบทช่วยสอน TensorFlow นี้ TensorFlow เป็นเฟรมเวิร์กที่มีประสิทธิภาพที่ทำให้การทำงานกับนิพจน์ทางคณิตศาสตร์และอาร์เรย์หลายมิติเป็นเรื่องง่ายซึ่งเป็นสิ่งที่จำเป็นโดยพื้นฐานในการเรียนรู้ของเครื่อง นอกจากนี้ยังขจัดความซับซ้อนของการเรียกใช้กราฟข้อมูลและการปรับขนาด
เมื่อเวลาผ่านไป TensorFlow ได้รับความนิยมเพิ่มขึ้นและขณะนี้นักพัฒนาใช้ในการแก้ปัญหาโดยใช้วิธีการเรียนรู้เชิงลึกสำหรับการจดจำภาพการตรวจจับวิดีโอการประมวลผลข้อความเช่นการวิเคราะห์ความรู้สึก ฯลฯ เช่นเดียวกับห้องสมุดอื่น ๆ คุณอาจต้องใช้เวลาสักพักเพื่อใช้งาน กับแนวคิดที่ TensorFlow สร้างขึ้น และเมื่อคุณทำเสร็จแล้วด้วยความช่วยเหลือของเอกสารและการสนับสนุนจากชุมชนการแสดงปัญหาเป็นกราฟข้อมูลและการแก้ปัญหาด้วย TensorFlow สามารถทำให้การเรียนรู้ของเครื่องในระดับที่เหมาะสมเป็นกระบวนการที่น่าเบื่อน้อยลง
วิธีสร้างงานค้างสินค้า
ทำความเข้าใจพื้นฐาน
TensorFlow สร้างขึ้นได้อย่างไร
ใน TensorFlow ค่าคงที่ถูกสร้างขึ้นโดยใช้ฟังก์ชันค่าคงที่ซึ่งรับพารามิเตอร์ไม่กี่ตัว: ค่า, dtype (ชนิดข้อมูล), รูปร่าง, ชื่อและการตรวจสอบรูปร่าง (Ver_shape)
เซสชัน TensorFlow คืออะไร?
เซสชันจะห่อหุ้มการควบคุมและสถานะของรันไทม์ TensorFlow เซสชันที่ไม่มีพารามิเตอร์จะใช้กราฟเริ่มต้นที่สร้างขึ้นในเซสชันปัจจุบันมิฉะนั้นคลาสเซสชันจะยอมรับพารามิเตอร์กราฟซึ่งใช้ในเซสชันนั้นเพื่อดำเนินการ
TensorBoard คืออะไร?
TensorBoard เป็นเครื่องมือแสดงภาพสำหรับวิเคราะห์กราฟกระแสข้อมูล ซึ่งจะมีประโยชน์ในการทำความเข้าใจโมเดลแมชชีนเลิร์นนิงให้ดีขึ้น
