portaldacalheta.pt
  • หลัก
  • การทำกำไรและประสิทธิภาพ
  • การออกแบบ Ux
  • เทคโนโลยี
  • การออกแบบตราสินค้า
เทคโนโลยี

เริ่มต้นใช้งาน TensorFlow: บทช่วยสอน Machine Learning



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

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



TensorFlow บทช่วยสอน



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

TensorBoard Graph View

ตอนนี้กลับไปที่ตัวอย่างของเราตั้งแต่เริ่มต้นของบทช่วยสอน 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 กราฟการไหลของข้อมูล

TensorBoard ทำเครื่องหมายค่าคงที่และสัญลักษณ์เฉพาะโหนดสรุปซึ่งอธิบายไว้ด้านล่าง

ไอคอนกราฟ

คณิตศาสตร์กับ TensorFlow

Tensors เป็นโครงสร้างข้อมูลพื้นฐานใน TensorFlow และแสดงขอบเชื่อมต่อในกราฟกระแสข้อมูล

เทนเซอร์เพียงแค่ระบุอาร์เรย์หรือรายการหลายมิติ โครงสร้างเทนเซอร์สามารถระบุได้ด้วยพารามิเตอร์สามตัว ได้แก่ อันดับรูปร่างและประเภท

  • อันดับ: ระบุจำนวนมิติของเทนเซอร์ อันดับเรียกว่าลำดับหรือ n มิติของเทนเซอร์โดยตัวอย่างเช่นอันดับ 1 เทนเซอร์เป็นเวกเตอร์หรืออันดับ 2 เทนเซอร์เป็นเมทริกซ์
  • รูปร่าง: รูปร่างของเทนเซอร์คือจำนวนแถวและคอลัมน์ที่มี
  • ประเภท: ประเภทข้อมูลที่กำหนดให้กับองค์ประกอบเทนเซอร์

ในการสร้างเทนเซอร์ใน TensorFlow เราสามารถสร้างอาร์เรย์ n มิติ สิ่งนี้สามารถทำได้อย่างง่ายดายโดยใช้ไลบรารี NumPy หรือโดยการแปลงอาร์เรย์ n มิติของ Python เป็นเทนเซอร์ TensorFlow

Tensors ที่มีขนาดต่างกัน

ในการสร้างเทนเซอร์ 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) เป็นอัลกอริทึมการเรียนรู้ภายใต้การดูแลซึ่งใช้เมตริกระยะทางเช่นระยะทางแบบยุคลิดเพื่อจัดประเภทข้อมูลเทียบกับการฝึกอบรม เป็นหนึ่งในอัลกอริทึมที่ง่ายที่สุด แต่ยังคงมีประสิทธิภาพมากสำหรับการจำแนกประเภทข้อมูล ข้อดีของอัลกอริทึมนี้:

  • ให้ความแม่นยำสูงเมื่อแบบจำลองการฝึกอบรมมีขนาดใหญ่พอและ
  • โดยปกติแล้วไม่ได้มีความอ่อนไหวต่อค่าผิดปกติและเราไม่จำเป็นต้องมีข้อสันนิษฐานเกี่ยวกับข้อมูล

จุดด้อยของอัลกอริทึมนี้:

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

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 เป็นเครื่องมือแสดงภาพสำหรับวิเคราะห์กราฟกระแสข้อมูล ซึ่งจะมีประโยชน์ในการทำความเข้าใจโมเดลแมชชีนเลิร์นนิงให้ดีขึ้น

วิธีสร้างวิดเจ็ต Magento 2 แบบกำหนดเอง

แบ็คเอนด์

วิธีสร้างวิดเจ็ต Magento 2 แบบกำหนดเอง
ไขความลึกลับของการประเมินค่าตราสินค้า

ไขความลึกลับของการประเมินค่าตราสินค้า

กระบวนการทางการเงิน

โพสต์ยอดนิยม
Ractive.js - เว็บแอพที่ทำได้ง่าย
Ractive.js - เว็บแอพที่ทำได้ง่าย
การสอน Mirror API: Google Glass สำหรับนักพัฒนาเว็บ
การสอน Mirror API: Google Glass สำหรับนักพัฒนาเว็บ
ตลาดล้านดอลลาร์ดีกว่าตลาดพันล้านดอลลาร์หรือไม่?
ตลาดล้านดอลลาร์ดีกว่าตลาดพันล้านดอลลาร์หรือไม่?
ทำไมฉันต้องใช้ Node.js การสอนเป็นกรณี ๆ ไป
ทำไมฉันต้องใช้ Node.js การสอนเป็นกรณี ๆ ไป
รองประธานองค์กร
รองประธานองค์กร
 
สงครามเย็นแห่งเทคโนโลยี: ยังคงอยู่ที่นี่และยังคงถูกใช้
สงครามเย็นแห่งเทคโนโลยี: ยังคงอยู่ที่นี่และยังคงถูกใช้
ปรับขนาดด้วยความเร็ว: อธิบายเครือข่ายสายฟ้าของ Bitcoin
ปรับขนาดด้วยความเร็ว: อธิบายเครือข่ายสายฟ้าของ Bitcoin
ส่วนประกอบของปฏิกิริยาที่มีประสิทธิภาพ: คำแนะนำในการเพิ่มประสิทธิภาพการตอบสนอง
ส่วนประกอบของปฏิกิริยาที่มีประสิทธิภาพ: คำแนะนำในการเพิ่มประสิทธิภาพการตอบสนอง
คำแนะนำสำหรับนักพัฒนา Android เกี่ยวกับรูปแบบการเรียกดูตัวอย่างข้อมูล
คำแนะนำสำหรับนักพัฒนา Android เกี่ยวกับรูปแบบการเรียกดูตัวอย่างข้อมูล
การรับรองและการประกันการรับประกัน: เครื่องมือการควบรวมกิจการที่ผู้ขายทุกคนควรทราบ
การรับรองและการประกันการรับประกัน: เครื่องมือการควบรวมกิจการที่ผู้ขายทุกคนควรทราบ
โพสต์ยอดนิยม
  • ราสเบอร์รี่ pi เว็บเซิร์ฟเวอร์ nginx
  • c # บทช่วยสอนบอทที่ไม่ลงรอยกัน
  • การกระทำของแก้วสตีกัลทำให้เกิดภาวะถดถอยหรือไม่?
  • กวดวิชา c ++ ที่ดีที่สุด
  • รหัสโรงเรียน c++
  • หลักการนิยามความหลากหลายในการออกแบบ
  • วิธีการเขียนโปรแกรมหุ่นยนต์
หมวดหมู่
  • การทำกำไรและประสิทธิภาพ
  • การออกแบบ Ux
  • เทคโนโลยี
  • การออกแบบตราสินค้า
  • © 2022 | สงวนลิขสิทธิ์

    portaldacalheta.pt