TensorFlow - คู่มือฉบับย่อ

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

เว็บไซต์อย่างเป็นทางการของ TensorFlow มีการระบุไว้ด้านล่าง -

www.tensorflow.org

ให้เราพิจารณาคุณสมบัติที่สำคัญต่อไปนี้ของ TensorFlow -

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

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

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

TensorFlow เรียกอีกอย่างว่าผลิตภัณฑ์“ Google” ประกอบด้วยแมชชีนเลิร์นนิงและอัลกอริทึมการเรียนรู้เชิงลึกที่หลากหลาย TensorFlow สามารถฝึกและเรียกใช้เครือข่ายประสาทเทียมในระดับลึกสำหรับการจำแนกตัวเลขที่เขียนด้วยลายมือการจดจำภาพการฝังคำและการสร้างแบบจำลองลำดับต่างๆ

ในการติดตั้ง TensorFlow สิ่งสำคัญคือต้องติดตั้ง“ Python” ในระบบของคุณ Python เวอร์ชัน 3.4+ ถือว่าดีที่สุดในการเริ่มต้นด้วยการติดตั้ง TensorFlow

พิจารณาขั้นตอนต่อไปนี้เพื่อติดตั้ง TensorFlow ในระบบปฏิบัติการ Windows

Step 1 - ตรวจสอบเวอร์ชัน python ที่กำลังติดตั้ง

Step 2- ผู้ใช้สามารถเลือกกลไกใดก็ได้เพื่อติดตั้ง TensorFlow ในระบบ เราขอแนะนำ "pip" และ "Anaconda" Pip เป็นคำสั่งที่ใช้สำหรับดำเนินการและติดตั้งโมดูลใน Python

ก่อนที่เราจะติดตั้ง TensorFlow เราจำเป็นต้องติดตั้ง Anaconda framework ในระบบของเรา

หลังจากติดตั้งสำเร็จให้ตรวจสอบพร้อมรับคำสั่งผ่านคำสั่ง "conda" การดำเนินการของคำสั่งแสดงอยู่ด้านล่าง -

Step 3 - ดำเนินการคำสั่งต่อไปนี้เพื่อเริ่มต้นการติดตั้ง TensorFlow -

conda create --name tensorflow python = 3.5

ดาวน์โหลดแพ็คเกจที่จำเป็นสำหรับการตั้งค่า TensorFlow

Step 4 - หลังจากตั้งค่าสิ่งแวดล้อมสำเร็จแล้วสิ่งสำคัญคือต้องเปิดใช้งานโมดูล TensorFlow

activate tensorflow

Step 5- ใช้ pip เพื่อติดตั้ง“ Tensorflow” ในระบบ คำสั่งที่ใช้ในการติดตั้งมีดังต่อไปนี้ -

pip install tensorflow

และ,

pip install tensorflow-gpu

หลังจากติดตั้งสำเร็จสิ่งสำคัญคือต้องทราบตัวอย่างการทำงานของโปรแกรม TensorFlow

ตัวอย่างต่อไปนี้ช่วยให้เราเข้าใจการสร้างโปรแกรมพื้นฐาน“ Hello World” ใน TensorFlow

รหัสสำหรับการติดตั้งโปรแกรมครั้งแรกมีการระบุไว้ด้านล่าง -

>> activate tensorflow
>> python (activating python shell)
>> import tensorflow as tf
>> hello = tf.constant(‘Hello, Tensorflow!’)
>> sess = tf.Session()
>> print(sess.run(hello))

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

การเรียนรู้ของเครื่องเป็นสาขาของปัญญาประดิษฐ์ซึ่งเกี่ยวข้องกับระบบและอัลกอริทึมที่สามารถเรียนรู้ข้อมูลและรูปแบบข้อมูลใหม่ ๆ

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

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

รูปแบบควรได้รับการฝึกฝนเพื่อแสดงผลลัพธ์ในลักษณะที่พึงปรารถนา

การเรียนรู้ของเครื่องสามารถฝึกได้สองวิธี -

การฝึกอบรมภายใต้การดูแล
การฝึกอบรมที่ไม่มีผู้ดูแล

การเรียนรู้ภายใต้การดูแล

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

หลังจากเสร็จสิ้นการฝึกอบรมความแม่นยำของแต่ละแบบจะถูกวัดตามตัวอย่างที่ไม่ปะติดปะต่อจากชุดฝึกหรือที่เรียกว่าชุดการตรวจสอบ

ตัวอย่างที่ดีที่สุดในการแสดงให้เห็นถึง "การเรียนรู้ภายใต้การดูแล" คือรูปภาพจำนวนมากที่ให้ข้อมูลที่รวมอยู่ในนั้น ผู้ใช้สามารถฝึกนางแบบให้จดจำรูปภาพใหม่ได้ที่นี่

การเรียนรู้ที่ไม่มีผู้ดูแล

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

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

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

เวกเตอร์

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

อัลกอริทึมการเรียนรู้ของเครื่องจัดการกับข้อมูลหลายมิติดังนั้นเวกเตอร์จึงมีบทบาทสำคัญ

การแสดงภาพของแบบจำลองเวกเตอร์มีดังที่แสดงด้านล่าง -

เกลา

สเกลาร์สามารถกำหนดเป็นเวกเตอร์มิติเดียว สเกลาร์คือสิ่งที่มีเพียงขนาดและไม่มีทิศทาง ด้วยสเกลาร์เราเกี่ยวข้องกับขนาดเท่านั้น

ตัวอย่างของสเกลาร์ ได้แก่ พารามิเตอร์น้ำหนักและส่วนสูงของเด็ก

เมทริกซ์

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

พิจารณาเมทริกซ์ที่มีแถว“ m” และคอลัมน์“ n” ตามที่กล่าวไว้ข้างต้นการแทนค่าเมทริกซ์จะถูกระบุเป็น“ เมทริกซ์ m * n” ซึ่งกำหนดความยาวของเมทริกซ์ด้วย

การคำนวณทางคณิตศาสตร์

ในส่วนนี้เราจะเรียนรู้เกี่ยวกับการคำนวณทางคณิตศาสตร์ต่างๆใน TensorFlow

การเพิ่มเมทริกซ์

สามารถเพิ่มเมทริกซ์สองตัวขึ้นไปได้หากเมทริกซ์มีมิติเดียวกัน การเพิ่มหมายถึงการเพิ่มของแต่ละองค์ประกอบตามตำแหน่งที่กำหนด

ลองพิจารณาตัวอย่างต่อไปนี้เพื่อทำความเข้าใจว่าการเพิ่มเมทริกซ์ทำงานอย่างไร -

$$ ตัวอย่าง: A = \ begin {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} B = \ begin {bmatrix} 5 & 6 \\ 7 & 8 \ end {bmatrix} \: then \: A + B = \ begin {bmatrix} 1 + 5 & 2 + 6 \\ 3 + 7 & 4 + 8 \ end {bmatrix} = \ begin {bmatrix} 6 & 8 \\ 10 & 12 \ end {bmatrix} $$

การลบเมทริกซ์

การลบเมทริกซ์ดำเนินการในลักษณะเดียวกันเช่นการบวกเมทริกซ์สองตัว ผู้ใช้สามารถลบเมทริกซ์สองตัวได้หากมิติข้อมูลเท่ากัน

$$ ตัวอย่าง: A- \ begin {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} B- \ begin {bmatrix} 5 & 6 \\ 7 & 8 \ end {bmatrix} \: then \: AB - \ begin {bmatrix} 1-5 & 2-6 \\ 3-7 & 4-8 \ end {bmatrix} - \ begin {bmatrix} -4 & -4 \\ - 4 & -4 \ end {bmatrix} $$

การคูณเมทริกซ์

สำหรับสองเมทริกซ์ A m * n และ B p * q ที่จะคูณได้ n ควรจะเท่ากับ p. เมทริกซ์ผลลัพธ์คือ -

ค m * q

$$ A = \ begin {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} B = \ begin {bmatrix} 5 & 6 \\ 7 & 8 \ end {bmatrix} $$

$$ c_ {11} = \ begin {bmatrix} 1 & 2 \ end {bmatrix} \ begin {bmatrix} 5 \\ 7 \ end {bmatrix} = 1 \ times5 + 2 \ times7 = 19 \: c_ {12} = \ begin {bmatrix} 1 & 2 \ end {bmatrix} \ begin {bmatrix} 6 \\ 8 \ end {bmatrix} = 1 \ times6 + 2 \ times8 = 22 $$

$$ c_ {21} = \ begin {bmatrix} 3 & 4 \ end {bmatrix} \ begin {bmatrix} 5 \\ 7 \ end {bmatrix} = 3 \ times5 + 4 \ times7 = 43 \: c_ {22} = \ begin {bmatrix} 3 & 4 \ end {bmatrix} \ begin {bmatrix} 6 \\ 8 \ end {bmatrix} = 3 \ times6 + 4 \ times8 = 50 $$

$$ C = \ begin {bmatrix} c_ {11} & c_ {12} \\ c_ {21} & c_ {22} \ end {bmatrix} = \ begin {bmatrix} 19 & 22 \\ 43 & 50 \ end {bmatrix} $$

การเปลี่ยนเมทริกซ์

ทรานสโพสของเมทริกซ์ A, m * n โดยทั่วไปจะแสดงด้วย AT (ทรานสโพส) n * m และหาได้จากการย้ายเวกเตอร์คอลัมน์เป็นเวกเตอร์แถว

$$ ตัวอย่าง: A = \ begin {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} \: then \: A ^ {T} \ begin {bmatrix} 1 & 3 \\ 2 & 4 \ end { bmatrix} $$

Dot product ของเวกเตอร์

เวกเตอร์ของมิติใด ๆ n สามารถแสดงเป็นเมทริกซ์ v = R ^ n * 1

$$ v_ {1} = \ begin {bmatrix} v_ {11} \\ v_ {12} \\\ cdot \\\ cdot \\\ cdot \\ v_ {1n} \ end {bmatrix} v_ {2} = \ start {bmatrix} v_ {21} \\ v_ {22} \\\ cdot \\\ cdot \\\ cdot \\ v_ {2n} \ end {bmatrix} $$

ดอทโปรดัคของเวกเตอร์สองตัวคือผลรวมของผลคูณของส่วนประกอบที่เกี่ยวข้อง - ส่วนประกอบในมิติเดียวกันและสามารถแสดงเป็น

$$ v_ {1} \ cdot v_ {2} = v_1 ^ Tv_ {2} = v_2 ^ Tv_ {1} = v_ {11} v_ {21} + v_ {12} v_ {22} + \ cdot \ cdot + v_ {1n} v_ {2n} = \ displaystyle \ sum \ LIMIT_ {k = 1} ^ n v_ {1k} v_ {2k} $$

ตัวอย่างของ dot product ของเวกเตอร์มีดังต่อไปนี้ -

$$ ตัวอย่าง: v_ {1} = \ begin {bmatrix} 1 \\ 2 \\ 3 \ end {bmatrix} v_ {2} = \ begin {bmatrix} 3 \\ 5 \\ - 1 \ end {bmatrix} v_ {1} \ cdot v_ {2} = v_1 ^ Tv_ {2} = 1 \ times3 + 2 \ times5-3 \ times1 = 10 $$

ปัญญาประดิษฐ์เป็นหนึ่งในเทรนด์ยอดนิยมในช่วงเวลาที่ผ่านมา การเรียนรู้ของเครื่องและการเรียนรู้เชิงลึกเป็นปัญญาประดิษฐ์ แผนภาพเวนน์ที่แสดงด้านล่างอธิบายความสัมพันธ์ของการเรียนรู้ของเครื่องและการเรียนรู้เชิงลึก -

การเรียนรู้ของเครื่อง

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

รูปแบบการเรียนรู้ภายใต้การดูแล
รูปแบบการเรียนรู้ที่ไม่มีผู้ดูแล

การเรียนรู้เชิงลึก

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

คุณค่าทั้งหมดของการเรียนรู้เชิงลึกในปัจจุบันคือการเรียนรู้ภายใต้การดูแลหรือการเรียนรู้จากข้อมูลและอัลกอริทึมที่มีป้ายกำกับ

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

พิจารณาขั้นตอนต่อไปนี้ที่กำหนดกระบวนการเรียนรู้ของเครื่อง

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

ความแตกต่างระหว่าง Machine Learning และ Deep Learning

ในส่วนนี้เราจะเรียนรู้เกี่ยวกับความแตกต่างระหว่าง Machine Learning และ Deep Learning

จำนวนข้อมูล

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

การพึ่งพาฮาร์ดแวร์

อัลกอริธึมการเรียนรู้เชิงลึกได้รับการออกแบบมาเพื่อพึ่งพาเครื่องจักรระดับไฮเอนด์อย่างมากซึ่งแตกต่างจากอัลกอริทึมการเรียนรู้ของเครื่องแบบเดิม อัลกอริธึมการเรียนรู้เชิงลึกดำเนินการคูณเมทริกซ์จำนวนมากซึ่งต้องการการสนับสนุนฮาร์ดแวร์จำนวนมาก

วิศวกรรมคุณลักษณะ

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

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

แนวทางการแก้ปัญหา

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

เวลาดำเนินการ

เวลาดำเนินการคือระยะเวลาที่ต้องใช้ในการฝึกอัลกอริทึม การเรียนรู้เชิงลึกต้องใช้เวลามากในการฝึกฝนเนื่องจากมีพารามิเตอร์จำนวนมากซึ่งใช้เวลานานกว่าปกติ อัลกอริทึมการเรียนรู้ของเครื่องค่อนข้างใช้เวลาในการดำเนินการน้อยกว่า

การตีความ

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

การประยุกต์ใช้ Machine Learning และ Deep Learning

ในส่วนนี้เราจะเรียนรู้เกี่ยวกับแอปพลิเคชันต่างๆของ Machine Learning และ Deep Learning

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

แนวโน้มในอนาคต

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

สรุป

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

ในบทนี้เราจะเรียนรู้เกี่ยวกับพื้นฐานของ TensorFlow เราจะเริ่มต้นด้วยการทำความเข้าใจโครงสร้างข้อมูลของเทนเซอร์

โครงสร้างข้อมูลเทนเซอร์

Tensors ใช้เป็นโครงสร้างข้อมูลพื้นฐานในภาษา TensorFlow Tensors แสดงขอบเชื่อมต่อในแผนภาพการไหลใด ๆ ที่เรียกว่า Data Flow Graph Tensors ถูกกำหนดให้เป็นอาร์เรย์หรือรายการหลายมิติ

Tensors ถูกระบุโดยพารามิเตอร์สามตัวต่อไปนี้ -

อันดับ

หน่วยของมิติที่อธิบายภายในเทนเซอร์เรียกว่าอันดับ ระบุจำนวนมิติของเทนเซอร์ อันดับของเทนเซอร์สามารถอธิบายได้ว่าเป็นลำดับหรือขนาด n ของเทนเซอร์ที่กำหนด

รูปร่าง

จำนวนแถวและคอลัมน์ร่วมกันกำหนดรูปร่างของ Tensor

ประเภท

Type อธิบายประเภทข้อมูลที่กำหนดให้กับองค์ประกอบของ Tensor

ผู้ใช้ต้องพิจารณากิจกรรมต่อไปนี้เพื่อสร้าง Tensor -

สร้างอาร์เรย์ n มิติ
แปลงอาร์เรย์ n มิติ

ขนาดต่างๆของ TensorFlow

TensorFlow ประกอบด้วยมิติต่างๆ มิติข้อมูลมีคำอธิบายสั้น ๆ ด้านล่าง -

Tensor หนึ่งมิติ

เทนเซอร์หนึ่งมิติเป็นโครงสร้างอาร์เรย์ปกติซึ่งรวมค่าหนึ่งชุดของประเภทข้อมูลเดียวกัน

Declaration

>>> import numpy as np
>>> tensor_1d = np.array([1.3, 1, 4.0, 23.99])
>>> print tensor_1d

การใช้งานกับผลลัพธ์จะแสดงในภาพหน้าจอด้านล่าง -

การสร้างดัชนีขององค์ประกอบจะเหมือนกับรายการ Python องค์ประกอบแรกเริ่มต้นด้วยดัชนี 0; ในการพิมพ์ค่าผ่านดัชนีสิ่งที่คุณต้องทำคือระบุหมายเลขดัชนี

>>> print tensor_1d[0]
1.3
>>> print tensor_1d[2]
4.0

Tensors สองมิติ

ลำดับของอาร์เรย์ใช้สำหรับการสร้าง "เทนเซอร์สองมิติ"

การสร้างเทนเซอร์สองมิติอธิบายไว้ด้านล่าง -

ต่อไปนี้เป็นไวยากรณ์ที่สมบูรณ์สำหรับการสร้างอาร์เรย์สองมิติ -

>>> import numpy as np
>>> tensor_2d = np.array([(1,2,3,4),(4,5,6,7),(8,9,10,11),(12,13,14,15)])
>>> print(tensor_2d)
[[ 1 2 3 4]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
>>>

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

>>> tensor_2d[3][2]
14

การจัดการและการจัดการ Tensor

ในส่วนนี้เราจะเรียนรู้เกี่ยวกับการจัดการและการจัดการเทนเซอร์

ในการเริ่มต้นให้เราพิจารณารหัสต่อไปนี้ -

import tensorflow as tf
import numpy as np

matrix1 = np.array([(2,2,2),(2,2,2),(2,2,2)],dtype = 'int32')
matrix2 = np.array([(1,1,1),(1,1,1),(1,1,1)],dtype = 'int32')

print (matrix1)
print (matrix2)

matrix1 = tf.constant(matrix1)
matrix2 = tf.constant(matrix2)
matrix_product = tf.matmul(matrix1, matrix2)
matrix_sum = tf.add(matrix1,matrix2)
matrix_3 = np.array([(2,7,2),(1,4,2),(9,0,2)],dtype = 'float32')
print (matrix_3)

matrix_det = tf.matrix_determinant(matrix_3)
with tf.Session() as sess:
   result1 = sess.run(matrix_product)
   result2 = sess.run(matrix_sum)
   result3 = sess.run(matrix_det)

print (result1)
print (result2)
print (result3)

Output

โค้ดด้านบนจะสร้างผลลัพธ์ต่อไปนี้ -

คำอธิบาย

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

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

ต่อไปนี้เป็นเครือข่ายประสาทเทียมที่สำคัญสองประเภท -

Convolutional Neural Networks
เครือข่ายประสาทที่กำเริบ

ในบทนี้เราจะมุ่งเน้นไปที่ CNN, Convolutional Neural Networks

Convolutional Neural Networks

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

แนวทางที่โดดเด่นของ CNN ได้แก่ การแก้ปัญหาการรับรู้ บริษัท ชั้นนำอย่าง Google และ Facebook ได้ลงทุนในการวิจัยและพัฒนาไปสู่โครงการการรับรู้เพื่อให้ทำกิจกรรมต่างๆได้อย่างรวดเร็วยิ่งขึ้น

โครงข่ายประสาทเทียมใช้แนวคิดพื้นฐานสามประการ -

เขตข้อมูลที่เกี่ยวข้อง
Convolution
Pooling

ให้เราเข้าใจแนวคิดเหล่านี้โดยละเอียด

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

ต่อไปนี้เป็นการแสดงไดอะแกรมของการสร้างฟิลด์ในท้องถิ่น -

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

การแมปการเชื่อมต่อจากเลเยอร์อินพุตไปยังแมปคุณลักษณะที่ซ่อนอยู่ถูกกำหนดเป็น "น้ำหนักที่ใช้ร่วมกัน" และการรวมอคติเรียกว่า "อคติร่วม"

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

การใช้งาน TensorFlow ของ CNN

ในส่วนนี้เราจะเรียนรู้เกี่ยวกับการใช้งาน TensorFlow ของ CNN ขั้นตอนซึ่งต้องใช้การดำเนินการและขนาดที่เหมาะสมของเครือข่ายทั้งหมดมีดังที่แสดงด้านล่าง -

Step 1 - รวมโมดูลที่จำเป็นสำหรับ TensorFlow และโมดูลชุดข้อมูลซึ่งจำเป็นในการคำนวณโมเดล CNN

import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

Step 2 - ประกาศฟังก์ชันที่เรียกว่า run_cnn()ซึ่งรวมถึงพารามิเตอร์ต่างๆและตัวแปรการเพิ่มประสิทธิภาพพร้อมการประกาศตัวยึดข้อมูล ตัวแปรการเพิ่มประสิทธิภาพเหล่านี้จะประกาศรูปแบบการฝึกอบรม

def run_cnn():
   mnist = input_data.read_data_sets("MNIST_data/", one_hot = True)
   learning_rate = 0.0001
   epochs = 10
   batch_size = 50

Step 3 - ในขั้นตอนนี้เราจะประกาศตัวยึดข้อมูลการฝึกอบรมด้วยพารามิเตอร์อินพุต - สำหรับ 28 x 28 พิกเซล = 784 นี่คือข้อมูลภาพที่แบนซึ่งดึงมาจาก mnist.train.nextbatch().

เราสามารถปรับรูปร่างเทนเซอร์ได้ตามความต้องการของเรา ค่าแรก (-1) บอกให้ฟังก์ชันกำหนดมิติข้อมูลนั้นแบบไดนามิกตามปริมาณข้อมูลที่ส่งผ่านไป ขนาดกลางทั้งสองถูกกำหนดเป็นขนาดภาพ (เช่น 28 x 28)

x = tf.placeholder(tf.float32, [None, 784])
x_shaped = tf.reshape(x, [-1, 28, 28, 1])
y = tf.placeholder(tf.float32, [None, 10])

Step 4 - ตอนนี้สิ่งสำคัญคือต้องสร้างเลเยอร์ที่ซับซ้อน -

layer1 = create_new_conv_layer(x_shaped, 1, 32, [5, 5], [2, 2], name = 'layer1')
layer2 = create_new_conv_layer(layer1, 32, 64, [5, 5], [2, 2], name = 'layer2')

Step 5- ให้เราแบนเอาต์พุตให้พร้อมสำหรับขั้นตอนเอาต์พุตที่เชื่อมต่ออย่างสมบูรณ์ - หลังจากสองชั้นของก้าว 2 รวมกันที่มีขนาด 28 x 28 เป็นขนาด 14 x 14 หรือต่ำสุด 7 x 7 x, y พิกัด แต่มี 64 ช่องสัญญาณออก ในการสร้างเลเยอร์ "หนาแน่น" ที่เชื่อมต่อเต็มที่รูปร่างใหม่จะต้องเป็น [-1, 7 x 7 x 64] เราสามารถตั้งค่าน้ำหนักและค่าอคติสำหรับเลเยอร์นี้จากนั้นเปิดใช้งานด้วย ReLU

flattened = tf.reshape(layer2, [-1, 7 * 7 * 64])

wd1 = tf.Variable(tf.truncated_normal([7 * 7 * 64, 1000], stddev = 0.03), name = 'wd1')
bd1 = tf.Variable(tf.truncated_normal([1000], stddev = 0.01), name = 'bd1')

dense_layer1 = tf.matmul(flattened, wd1) + bd1
dense_layer1 = tf.nn.relu(dense_layer1)

Step 6 - อีกชั้นหนึ่งที่มีการเปิดใช้งานซอฟต์แม็กซ์เฉพาะด้วยเครื่องมือเพิ่มประสิทธิภาพที่จำเป็นจะกำหนดการประเมินความแม่นยำซึ่งจะทำให้การตั้งค่าตัวดำเนินการเริ่มต้น

wd2 = tf.Variable(tf.truncated_normal([1000, 10], stddev = 0.03), name = 'wd2')
bd2 = tf.Variable(tf.truncated_normal([10], stddev = 0.01), name = 'bd2')

dense_layer2 = tf.matmul(dense_layer1, wd2) + bd2
y_ = tf.nn.softmax(dense_layer2)

cross_entropy = tf.reduce_mean(
   tf.nn.softmax_cross_entropy_with_logits(logits = dense_layer2, labels = y))

optimiser = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

init_op = tf.global_variables_initializer()

Step 7- เราควรตั้งค่าตัวแปรการบันทึก สิ่งนี้จะเพิ่มข้อมูลสรุปเพื่อจัดเก็บความถูกต้องของข้อมูล

tf.summary.scalar('accuracy', accuracy)
   merged = tf.summary.merge_all()
   writer = tf.summary.FileWriter('E:\TensorFlowProject')
   
   with tf.Session() as sess:
      sess.run(init_op)
      total_batch = int(len(mnist.train.labels) / batch_size)
      
      for epoch in range(epochs):
         avg_cost = 0
      for i in range(total_batch):
         batch_x, batch_y = mnist.train.next_batch(batch_size = batch_size)
            _, c = sess.run([optimiser, cross_entropy], feed_dict = {
            x:batch_x, y: batch_y})
            avg_cost += c / total_batch
         test_acc = sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
            summary = sess.run(merged, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
         writer.add_summary(summary, epoch)

   print("\nTraining complete!")
   writer.add_graph(sess.graph)
   print(sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
      mnist.test.labels}))

def create_new_conv_layer(
   input_data, num_input_channels, num_filters,filter_shape, pool_shape, name):

   conv_filt_shape = [
      filter_shape[0], filter_shape[1], num_input_channels, num_filters]

   weights = tf.Variable(
      tf.truncated_normal(conv_filt_shape, stddev = 0.03), name = name+'_W')
   bias = tf.Variable(tf.truncated_normal([num_filters]), name = name+'_b')

#Out layer defines the output
   out_layer =
      tf.nn.conv2d(input_data, weights, [1, 1, 1, 1], padding = 'SAME')

   out_layer += bias
   out_layer = tf.nn.relu(out_layer)
   ksize = [1, pool_shape[0], pool_shape[1], 1]
   strides = [1, 2, 2, 1]
   out_layer = tf.nn.max_pool(
      out_layer, ksize = ksize, strides = strides, padding = 'SAME')

   return out_layer

if __name__ == "__main__":
run_cnn()

ต่อไปนี้เป็นผลลัพธ์ที่สร้างขึ้นโดยรหัสด้านบน -

See @{tf.nn.softmax_cross_entropy_with_logits_v2}.

2018-09-19 17:22:58.802268: I
T:\src\github\tensorflow\tensorflow\core\platform\cpu_feature_guard.cc:140]
Your CPU supports instructions that this TensorFlow binary was not compiled to
use: AVX2

2018-09-19 17:25:41.522845: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

2018-09-19 17:25:44.630941: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 501760000 exceeds 10% of system memory.

Epoch: 1 cost = 0.676 test accuracy: 0.940

2018-09-19 17:26:51.987554: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

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

พิจารณาขั้นตอนต่อไปนี้เพื่อฝึกโครงข่ายประสาทที่เกิดซ้ำ -

Step 1 - ป้อนตัวอย่างเฉพาะจากชุดข้อมูล

Step 2 - เครือข่ายจะนำตัวอย่างและคำนวณการคำนวณบางอย่างโดยใช้ตัวแปรเริ่มต้นแบบสุ่ม

Step 3 - คำนวณผลลัพธ์ที่คาดการณ์แล้ว

Step 4 - การเปรียบเทียบผลลัพธ์จริงที่สร้างขึ้นพร้อมกับค่าที่คาดหวังจะทำให้เกิดข้อผิดพลาด

Step 5 - ในการติดตามข้อผิดพลาดจะแพร่กระจายผ่านเส้นทางเดียวกันกับที่มีการปรับตัวแปรด้วย

Step 6 - ทำซ้ำขั้นตอนตั้งแต่ 1 ถึง 5 จนกว่าเราจะมั่นใจว่าตัวแปรที่ประกาศเพื่อให้ได้ผลลัพธ์ถูกกำหนดอย่างถูกต้อง

Step 7 - การทำนายอย่างเป็นระบบเกิดขึ้นโดยใช้ตัวแปรเหล่านี้เพื่อรับข้อมูลที่มองไม่เห็นใหม่

แผนผังของการแสดงโครงข่ายประสาทที่เกิดซ้ำได้อธิบายไว้ด้านล่าง -

การติดตั้งโครงข่ายประสาทเทียมซ้ำด้วย TensorFlow

ในส่วนนี้เราจะเรียนรู้วิธีการใช้เครือข่ายประสาทที่เกิดซ้ำด้วย TensorFlow

Step 1 - TensorFlow ประกอบด้วยไลบรารีต่างๆสำหรับการใช้งานโมดูลเครือข่ายประสาทที่เกิดซ้ำโดยเฉพาะ

#Import necessary modules
from __future__ import print_function

import tensorflow as tf
from tensorflow.contrib import rnn
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)

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

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

n_input = 28 # MNIST data input with img shape 28*28
n_steps = 28
n_hidden = 128
n_classes = 10

# tf Graph input
x = tf.placeholder("float", [None, n_steps, n_input])
y = tf.placeholder("float", [None, n_classes]
weights = {
   'out': tf.Variable(tf.random_normal([n_hidden, n_classes]))
}
biases = {
   'out': tf.Variable(tf.random_normal([n_classes]))
}

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

def RNN(x, weights, biases):
   x = tf.unstack(x, n_steps, 1)

   # Define a lstm cell with tensorflow
   lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)

   # Get lstm cell output
   outputs, states = rnn.static_rnn(lstm_cell, x, dtype = tf.float32)

   # Linear activation, using rnn inner loop last output
   return tf.matmul(outputs[-1], weights['out']) + biases['out']

pred = RNN(x, weights, biases)

# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = pred, labels = y))
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)

# Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initializing the variables
init = tf.global_variables_initializer()

Step 4- ในขั้นตอนนี้เราจะเปิดกราฟเพื่อรับผลการคำนวณ นอกจากนี้ยังช่วยในการคำนวณความแม่นยำสำหรับผลการทดสอบ

with tf.Session() as sess:
   sess.run(init)
   step = 1
   # Keep training until reach max iterations
   
   while step * batch_size < training_iters:
      batch_x, batch_y = mnist.train.next_batch(batch_size)
      batch_x = batch_x.reshape((batch_size, n_steps, n_input))
      sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})
      
      if step % display_step == 0:
         # Calculate batch accuracy
         acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y})
         
         # Calculate batch loss
         loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y})
         
         print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \
            "{:.6f}".format(loss) + ", Training Accuracy= " + \
            "{:.5f}".format(acc))
      step += 1
   print("Optimization Finished!")
      test_len = 128
   test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
   
   test_label = mnist.test.labels[:test_len]
   print("Testing Accuracy:", \
      sess.run(accuracy, feed_dict={x: test_data, y: test_label}))

ภาพหน้าจอด้านล่างแสดงผลลัพธ์ที่สร้างขึ้น -

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

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

การแสดงแผนผังต่อไปนี้แสดงการทำงานที่สมบูรณ์ของการแสดงภาพ TensorBoard -

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

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

import tensorflow as tf 

# Constants creation for TensorBoard visualization 
a = tf.constant(10,name = "a") 
b = tf.constant(90,name = "b") 
y = tf.Variable(a+b*2,name = 'y') 
model = tf.initialize_all_variables() #Creation of model 

with tf.Session() as session: 
   merged = tf.merge_all_summaries() 
   writer = tf.train.SummaryWriter("/tmp/tensorflowlogs",session.graph) 
   session.run(model) 
   print(session.run(y))

ตารางต่อไปนี้แสดงสัญลักษณ์ต่างๆของการแสดงภาพ TensorBoard ที่ใช้สำหรับการแสดงโหนด -

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

ตัวอย่างภาพประกอบการป้อนข้อมูลการฝังคำมีดังต่อไปนี้ -

blue: (0.01359, 0.00075997, 0.24608, ..., -0.2524, 1.0048, 0.06259)
blues: (0.01396, 0.11887, -0.48963, ..., 0.033483, -0.10007, 0.1158)
orange: (-0.24776, -0.12359, 0.20986, ..., 0.079717, 0.23865, -0.014213)
oranges: (-0.35609, 0.21854, 0.080944, ..., -0.35413, 0.38511, -0.070976)

Word2vec

Word2vec เป็นวิธีการทั่วไปที่ใช้สำหรับเทคนิคการฝังคำที่ไม่ได้รับการดูแล มันฝึกแบบจำลองในลักษณะที่คำป้อนข้อมูลที่กำหนดทำนายบริบทของคำนั้นโดยใช้การข้ามกรัม

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

import os 
import math 
import numpy as np 
import tensorflow as tf 

from tensorflow.contrib.tensorboard.plugins import projector 
batch_size = 64 
embedding_dimension = 5 
negative_samples = 8 
LOG_DIR = "logs/word2vec_intro" 

digit_to_word_map = {
   1: "One", 
   2: "Two", 
   3: "Three", 
   4: "Four", 
   5: "Five", 
   6: "Six", 
   7: "Seven", 
   8: "Eight", 
   9: "Nine"} 
sentences = [] 

# Create two kinds of sentences - sequences of odd and even digits. 
   for i in range(10000): 
   rand_odd_ints = np.random.choice(range(1, 10, 2), 3) 
      sentences.append(" ".join([digit_to_word_map[r] for r in rand_odd_ints])) 
   rand_even_ints = np.random.choice(range(2, 10, 2), 3) 
      sentences.append(" ".join([digit_to_word_map[r] for r in rand_even_ints])) 
   
# Map words to indices
word2index_map = {} 
index = 0 

for sent in sentences: 
   for word in sent.lower().split(): 
   
   if word not in word2index_map: 
      word2index_map[word] = index 
      index += 1 
index2word_map = {index: word for word, index in word2index_map.items()} 

vocabulary_size = len(index2word_map) 

# Generate skip-gram pairs 
skip_gram_pairs = [] 

for sent in sentences: 
   tokenized_sent = sent.lower().split() 
   
   for i in range(1, len(tokenized_sent)-1):        
      word_context_pair = [[word2index_map[tokenized_sent[i-1]], 
         word2index_map[tokenized_sent[i+1]]], word2index_map[tokenized_sent[i]]] 
      
      skip_gram_pairs.append([word_context_pair[1], word_context_pair[0][0]]) 
      skip_gram_pairs.append([word_context_pair[1], word_context_pair[0][1]]) 

def get_skipgram_batch(batch_size): 
   instance_indices = list(range(len(skip_gram_pairs))) 
      np.random.shuffle(instance_indices)
   batch = instance_indices[:batch_size] 
   x = [skip_gram_pairs[i][0] for i in batch] 
   y = [[skip_gram_pairs[i][1]] for i in batch] 
   return x, y 
   
# batch example 
x_batch, y_batch = get_skipgram_batch(8) 
x_batch 
y_batch 
[index2word_map[word] for word in x_batch] [index2word_map[word[0]] for word in y_batch] 

# Input data, labels train_inputs = tf.placeholder(tf.int32, shape = [batch_size]) 
   train_labels = tf.placeholder(tf.int32, shape = [batch_size, 1]) 

# Embedding lookup table currently only implemented in CPU with 
   tf.name_scope("embeddings"): 
   embeddings = tf.Variable(    
      tf.random_uniform([vocabulary_size, embedding_dimension], -1.0, 1.0), 
         name = 'embedding') 
   # This is essentialy a lookup table 
   embed = tf.nn.embedding_lookup(embeddings, train_inputs) 
   
# Create variables for the NCE loss
nce_weights = tf.Variable(     
   tf.truncated_normal([vocabulary_size, embedding_dimension], stddev = 1.0 / 
      math.sqrt(embedding_dimension))) 
   
nce_biases = tf.Variable(tf.zeros([vocabulary_size])) 

loss = tf.reduce_mean(     
   tf.nn.nce_loss(weights = nce_weights, biases = nce_biases, inputs = embed, 
   labels = train_labels,num_sampled = negative_samples, 
   num_classes = vocabulary_size)) tf.summary.scalar("NCE_loss", loss) 
   
# Learning rate decay 
global_step = tf.Variable(0, trainable = False) 
   learningRate = tf.train.exponential_decay(learning_rate = 0.1, 
   global_step = global_step, decay_steps = 1000, decay_rate = 0.95, staircase = True) 

train_step = tf.train.GradientDescentOptimizer(learningRate).minimize(loss) 
   merged = tf.summary.merge_all() 
with tf.Session() as sess: 
   train_writer = tf.summary.FileWriter(LOG_DIR,    
      graph = tf.get_default_graph()) 
   saver = tf.train.Saver() 
   
   with open(os.path.join(LOG_DIR, 'metadata.tsv'), "w") as metadata: 
      metadata.write('Name\tClass\n') for k, v in index2word_map.items(): 
      metadata.write('%s\t%d\n' % (v, k)) 
   
   config = projector.ProjectorConfig() 
   embedding = config.embeddings.add() embedding.tensor_name = embeddings.name 
   
   # Link this tensor to its metadata file (e.g. labels). 
   embedding.metadata_path = os.path.join(LOG_DIR, 'metadata.tsv') 
      projector.visualize_embeddings(train_writer, config) 
   
   tf.global_variables_initializer().run() 
   
   for step in range(1000): 
      x_batch, y_batch = get_skipgram_batch(batch_size) summary, _ = sess.run(
         [merged, train_step], feed_dict = {train_inputs: x_batch, train_labels: y_batch})
      train_writer.add_summary(summary, step)
      
      if step % 100 == 0:
         saver.save(sess, os.path.join(LOG_DIR, "w2v_model.ckpt"), step)
         loss_value = sess.run(loss, feed_dict = {
            train_inputs: x_batch, train_labels: y_batch})
         print("Loss at %d: %.5f" % (step, loss_value))

   # Normalize embeddings before using
   norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keep_dims = True))
   normalized_embeddings = embeddings /
      norm normalized_embeddings_matrix = sess.run(normalized_embeddings)
   
ref_word = normalized_embeddings_matrix[word2index_map["one"]]

cosine_dists = np.dot(normalized_embeddings_matrix, ref_word)
ff = np.argsort(cosine_dists)[::-1][1:10] for f in ff: print(index2word_map[f])
print(cosine_dists[f])

เอาต์พุต

รหัสด้านบนสร้างผลลัพธ์ต่อไปนี้ -

เพื่อให้เข้าใจ Perceptron ชั้นเดียวสิ่งสำคัญคือต้องเข้าใจ Artificial Neural Networks (ANN) โครงข่ายประสาทเทียมเป็นระบบประมวลผลข้อมูลซึ่งกลไกดังกล่าวได้รับแรงบันดาลใจจากการทำงานของวงจรประสาทชีวภาพ โครงข่ายประสาทเทียมมีหน่วยประมวลผลจำนวนมากที่เชื่อมต่อกัน ต่อไปนี้คือการแสดงแผนผังของโครงข่ายประสาทเทียม -

แผนภาพแสดงให้เห็นว่าหน่วยที่ซ่อนอยู่สื่อสารกับเลเยอร์ภายนอก ในขณะที่หน่วยอินพุตและเอาต์พุตสื่อสารผ่านชั้นที่ซ่อนอยู่ของเครือข่ายเท่านั้น

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

สถาปัตยกรรมมีสองประเภท ประเภทเหล่านี้มุ่งเน้นไปที่การทำงานของโครงข่ายประสาทเทียมดังต่อไปนี้ -

Perceptron ชั้นเดียว
Perceptron หลายชั้น

Perceptron ชั้นเดียว

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

ให้เรามุ่งเน้นไปที่การนำ perceptron ชั้นเดียวไปใช้สำหรับปัญหาการจำแนกภาพโดยใช้ TensorFlow ตัวอย่างที่ดีที่สุดในการแสดง Perceptron ชั้นเดียวคือการแสดง "Logistic Regression"

ตอนนี้ให้เราพิจารณาขั้นตอนพื้นฐานของการฝึกอบรมการถดถอยโลจิสติกส์ -

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

รหัสที่สมบูรณ์สำหรับการประเมินการถดถอยโลจิสติกมีการระบุไว้ด้านล่าง -

# Import MINST data 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True) 

import tensorflow as tf 
import matplotlib.pyplot as plt 

# Parameters 
learning_rate = 0.01 
training_epochs = 25 
batch_size = 100 
display_step = 1 

# tf Graph Input 
x = tf.placeholder("float", [None, 784]) # mnist data image of shape 28*28 = 784 
y = tf.placeholder("float", [None, 10]) # 0-9 digits recognition => 10 classes 

# Create model 
# Set model weights 
W = tf.Variable(tf.zeros([784, 10])) 
b = tf.Variable(tf.zeros([10])) 

# Construct model 
activation = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax 

# Minimize error using cross entropy 
cross_entropy = y*tf.log(activation) 
cost = tf.reduce_mean\ (-tf.reduce_sum\ (cross_entropy,reduction_indices = 1)) 

optimizer = tf.train.\ GradientDescentOptimizer(learning_rate).minimize(cost) 

#Plot settings 
avg_set = [] 
epoch_set = [] 

# Initializing the variables init = tf.initialize_all_variables()
# Launch the graph 
with tf.Session() as sess:
   sess.run(init)
   
   # Training cycle
   for epoch in range(training_epochs):
      avg_cost = 0.
      total_batch = int(mnist.train.num_examples/batch_size)
      
      # Loop over all batches
      for i in range(total_batch):
         batch_xs, batch_ys = \ mnist.train.next_batch(batch_size)
         # Fit training using batch data sess.run(optimizer, \ feed_dict = {
            x: batch_xs, y: batch_ys}) 
         # Compute average loss avg_cost += sess.run(cost, \ feed_dict = {
            x: batch_xs, \ y: batch_ys})/total_batch
      # Display logs per epoch step
      if epoch % display_step == 0:
         print ("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))
            avg_set.append(avg_cost) epoch_set.append(epoch+1)
   print ("Training phase finished")
    
   plt.plot(epoch_set,avg_set, 'o', label = 'Logistic Regression Training phase') 
   plt.ylabel('cost') 
   plt.xlabel('epoch') 
   plt.legend() 
   plt.show() 
    
   # Test model 
   correct_prediction = tf.equal(tf.argmax(activation, 1), tf.argmax(y, 1)) 
   
   # Calculate accuracy 
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print 
      ("Model accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

เอาต์พุต

รหัสด้านบนสร้างผลลัพธ์ต่อไปนี้ -

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

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

ความสัมพันธ์ระหว่างตัวแปรทั้งสองนี้ถือว่าเป็นเชิงเส้น ถ้า y เป็นตัวแปรตามและ x ถือเป็นตัวแปรอิสระความสัมพันธ์การถดถอยเชิงเส้นของสองตัวแปรจะมีลักษณะเหมือนสมการต่อไปนี้ -

Y = Ax+b

เราจะออกแบบอัลกอริทึมสำหรับการถดถอยเชิงเส้น สิ่งนี้จะช่วยให้เราเข้าใจแนวคิดสำคัญสองประการต่อไปนี้ -

ฟังก์ชันต้นทุน
อัลกอริทึมการไล่ระดับสี

การแสดงแผนผังของการถดถอยเชิงเส้นแสดงไว้ด้านล่าง -

มุมมองกราฟิกของสมการการถดถอยเชิงเส้นมีการกล่าวถึงด้านล่าง -

ขั้นตอนในการออกแบบอัลกอริทึมสำหรับการถดถอยเชิงเส้น

ตอนนี้เราจะเรียนรู้เกี่ยวกับขั้นตอนที่ช่วยในการออกแบบอัลกอริทึมสำหรับการถดถอยเชิงเส้น

ขั้นตอนที่ 1

สิ่งสำคัญคือต้องนำเข้าโมดูลที่จำเป็นสำหรับการพล็อตโมดูลการถดถอยเชิงเส้น เราเริ่มนำเข้าไลบรารี Python NumPy และ Matplotlib

import numpy as np 
import matplotlib.pyplot as plt

ขั้นตอนที่ 2

กำหนดจำนวนค่าสัมประสิทธิ์ที่จำเป็นสำหรับการถดถอยโลจิสติก

number_of_points = 500 
x_point = [] 
y_point = [] 
a = 0.22 
b = 0.78

ขั้นตอนที่ 3

ทำซ้ำตัวแปรเพื่อสร้างจุดสุ่ม 300 จุดรอบสมการถดถอย -

Y = 0.22x + 0.78

for i in range(number_of_points): 
   x = np.random.normal(0.0,0.5) 
   y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x]) 
   y_point.append([y])

ขั้นตอนที่ 4

ดูจุดที่สร้างขึ้นโดยใช้ Matplotlib

fplt.plot(x_point,y_point, 'o', label = 'Input Data') plt.legend() plt.show()

รหัสที่สมบูรณ์สำหรับการถดถอยโลจิสติกมีดังนี้ -

import numpy as np 
import matplotlib.pyplot as plt 

number_of_points = 500 
x_point = [] 
y_point = [] 
a = 0.22 
b = 0.78 

for i in range(number_of_points): 
   x = np.random.normal(0.0,0.5) 
   y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x]) 
   y_point.append([y]) 
   
plt.plot(x_point,y_point, 'o', label = 'Input Data') plt.legend() 
plt.show()

จำนวนจุดที่นำมาเป็นอินพุตถือเป็นข้อมูลอินพุต

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

พิจารณาคุณสมบัติที่สำคัญของ TFLearn ดังต่อไปนี้ -

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

ติดตั้ง TFLearn โดยดำเนินการคำสั่งต่อไปนี้ -

pip install tflearn

เมื่อดำเนินการตามรหัสข้างต้นผลลัพธ์ต่อไปนี้จะถูกสร้างขึ้น -

ภาพประกอบต่อไปนี้แสดงการนำ TFLearn ไปใช้กับ Random Forest classifier -

from __future__ import division, print_function, absolute_import

#TFLearn module implementation
import tflearn
from tflearn.estimators import RandomForestClassifier

# Data loading and pre-processing with respect to dataset
import tflearn.datasets.mnist as mnist
X, Y, testX, testY = mnist.load_data(one_hot = False)

m = RandomForestClassifier(n_estimators = 100, max_nodes = 1000)
m.fit(X, Y, batch_size = 10000, display_step = 10)

print("Compute the accuracy on train data:")
print(m.evaluate(X, Y, tflearn.accuracy_op))

print("Compute the accuracy on test set:")
print(m.evaluate(testX, testY, tflearn.accuracy_op))

print("Digits for test images id 0 to 5:")
print(m.predict(testX[:5]))

print("True digits:")
print(testY[:5])

ในบทนี้เราจะเน้นไปที่ความแตกต่างระหว่าง CNN และ RNN -

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

ภาพประกอบต่อไปนี้แสดงแผนผังของ CNN และ RNN -

Keras มีขนาดกะทัดรัดเรียนรู้ได้ง่ายไลบรารี Python ระดับสูงทำงานบน TensorFlow framework สร้างขึ้นโดยเน้นที่การทำความเข้าใจเทคนิคการเรียนรู้เชิงลึกเช่นการสร้างเลเยอร์สำหรับเครือข่ายประสาทเทียมที่คงไว้ซึ่งแนวคิดของรูปทรงและรายละเอียดทางคณิตศาสตร์ การสร้าง freamework สามารถทำได้สองประเภทต่อไปนี้ -

Sequential API
API การทำงาน

พิจารณาแปดขั้นตอนต่อไปนี้เพื่อสร้างแบบจำลองการเรียนรู้เชิงลึกใน Keras -

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

เราจะใช้ Jupyter Notebook ในการดำเนินการและแสดงผลตามที่แสดงด้านล่าง -

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

import warnings
warnings.filterwarnings('ignore')

import numpy as np
np.random.seed(123) # for reproducibility

from keras.models import Sequential
from keras.layers import Flatten, MaxPool2D, Conv2D, Dense, Reshape, Dropout
from keras.utils import np_utils
Using TensorFlow backend.
from keras.datasets import mnist

# Load pre-shuffled MNIST data into train and test sets
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)

ขั้นตอนนี้สามารถกำหนดเป็น“ นำเข้าไลบรารีและโมดูล” ซึ่งหมายความว่าไลบรารีและโมดูลทั้งหมดจะถูกอิมพอร์ตเป็นขั้นตอนเริ่มต้น

Step 2 - ในขั้นตอนนี้เราจะกำหนดสถาปัตยกรรมแบบจำลอง -

model = Sequential()
model.add(Conv2D(32, 3, 3, activation = 'relu', input_shape = (28,28,1)))
model.add(Conv2D(32, 3, 3, activation = 'relu'))
model.add(MaxPool2D(pool_size = (2,2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation = 'relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation = 'softmax'))

Step 3 - ให้เรารวบรวมโมเดลที่ระบุ -

model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])

Step 4 - ตอนนี้เราจะพอดีกับโมเดลโดยใช้ข้อมูลการฝึกอบรม -

model.fit(X_train, Y_train, batch_size = 32, epochs = 10, verbose = 1)

ผลลัพธ์ของการทำซ้ำที่สร้างขึ้นมีดังนี้ -

Epoch 1/10 60000/60000 [==============================] - 65s - 
loss: 0.2124 - 
acc: 0.9345 
Epoch 2/10 60000/60000 [==============================] - 62s - 
loss: 0.0893 - 
acc: 0.9740 
Epoch 3/10 60000/60000 [==============================] - 58s - 
loss: 0.0665 - 
acc: 0.9802 
Epoch 4/10 60000/60000 [==============================] - 62s - 
loss: 0.0571 - 
acc: 0.9830 
Epoch 5/10 60000/60000 [==============================] - 62s - 
loss: 0.0474 - 
acc: 0.9855 
Epoch 6/10 60000/60000 [==============================] - 59s -
loss: 0.0416 - 
acc: 0.9871 
Epoch 7/10 60000/60000 [==============================] - 61s - 
loss: 0.0380 - 
acc: 0.9877 
Epoch 8/10 60000/60000 [==============================] - 63s - 
loss: 0.0333 - 
acc: 0.9895 
Epoch 9/10 60000/60000 [==============================] - 64s - 
loss: 0.0325 - 
acc: 0.9898 
Epoch 10/10 60000/60000 [==============================] - 60s - 
loss: 0.0284 - 
acc: 0.9910

บทนี้จะเน้นเกี่ยวกับวิธีเริ่มต้นใช้งาน TensorFlow แบบกระจาย จุดมุ่งหมายคือเพื่อช่วยให้นักพัฒนาเข้าใจแนวคิดพื้นฐานของ TF แบบกระจายที่เกิดขึ้นอีกครั้งเช่นเซิร์ฟเวอร์ TF เราจะใช้ Jupyter Notebook สำหรับการประเมิน TensorFlow แบบกระจาย การใช้งานคอมพิวเตอร์แบบกระจายกับ TensorFlow มีดังต่อไปนี้ -

Step 1 - นำเข้าโมดูลที่จำเป็นซึ่งจำเป็นสำหรับการประมวลผลแบบกระจาย -

import tensorflow as tf

Step 2- สร้างคลัสเตอร์ TensorFlow ด้วยโหนดเดียว ให้โหนดนี้รับผิดชอบงานที่มีชื่อ "คนงาน" และจะดำเนินการหนึ่งครั้งที่ localhost: 2222

cluster_spec = tf.train.ClusterSpec({'worker' : ['localhost:2222']})
server = tf.train.Server(cluster_spec)
server.target

สคริปต์ข้างต้นสร้างผลลัพธ์ต่อไปนี้ -

'grpc://localhost:2222'
The server is currently running.

Step 3 - การกำหนดค่าเซิร์ฟเวอร์ด้วยเซสชันที่เกี่ยวข้องสามารถคำนวณได้โดยดำเนินการคำสั่งต่อไปนี้ -

server.server_def

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้ -

cluster {
   job {
      name: "worker"
      tasks {
         value: "localhost:2222"
      }
   }
}
job_name: "worker"
protocol: "grpc"

Step 4- เปิดเซสชัน TensorFlow โดยมีเอ็นจิ้นการดำเนินการเป็นเซิร์ฟเวอร์ ใช้ TensorFlow เพื่อสร้างเซิร์ฟเวอร์ภายในและใช้lsof เพื่อค้นหาตำแหน่งของเซิร์ฟเวอร์

sess = tf.Session(target = server.target)
server = tf.train.Server.create_local_server()

Step 5 - ดูอุปกรณ์ที่มีในเซสชันนี้และปิดเซสชันที่เกี่ยวข้อง

devices = sess.list_devices()
for d in devices:
   print(d.name)
sess.close()

คำสั่งดังกล่าวสร้างผลลัพธ์ต่อไปนี้ -

/job:worker/replica:0/task:0/device:CPU:0

ในที่นี้เราจะเน้นไปที่การสร้าง MetaGraph ใน TensorFlow สิ่งนี้จะช่วยให้เราเข้าใจโมดูลการส่งออกใน TensorFlow MetaGraph ประกอบด้วยข้อมูลพื้นฐานซึ่งจำเป็นสำหรับการฝึกอบรมทำการประเมินผลหรือเรียกใช้การอนุมานบนกราฟที่ได้รับการฝึกฝนมาก่อนหน้านี้

ต่อไปนี้เป็นข้อมูลโค้ดที่เหมือนกัน -

def export_meta_graph(filename = None, collection_list = None, as_text = False): 
   """this code writes `MetaGraphDef` to save_path/filename. 
   
   Arguments: 
   filename: Optional meta_graph filename including the path. collection_list: 
      List of string keys to collect. as_text: If `True`, 
      writes the meta_graph as an ASCII proto. 
   
   Returns: 
   A `MetaGraphDef` proto. """

หนึ่งในรูปแบบการใช้งานทั่วไปสำหรับสิ่งเดียวกันมีการระบุไว้ด้านล่าง -

# Build the model ... 
with tf.Session() as sess: 
   # Use the model ... 
# Export the model to /tmp/my-model.meta. 
meta_graph_def = tf.train.export_meta_graph(filename = '/tmp/my-model.meta')

Multi-Layer perceptron กำหนดสถาปัตยกรรมที่ซับซ้อนที่สุดของโครงข่ายประสาทเทียม มันถูกสร้างขึ้นอย่างมากจาก perceptron หลายชั้น

การแสดงแผนภาพของการเรียนรู้ Perceptron แบบหลายชั้นมีดังแสดงด้านล่าง -

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

ตอนนี้เราจะมุ่งเน้นไปที่การนำไปใช้กับ MLP สำหรับปัญหาการจัดประเภทรูปภาพ

# Import MINST data 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True) 

import tensorflow as tf 
import matplotlib.pyplot as plt 

# Parameters 
learning_rate = 0.001 
training_epochs = 20 
batch_size = 100 
display_step = 1 

# Network Parameters 
n_hidden_1 = 256 

# 1st layer num features
n_hidden_2 = 256 # 2nd layer num features 
n_input = 784 # MNIST data input (img shape: 28*28) n_classes = 10 
# MNIST total classes (0-9 digits) 

# tf Graph input 
x = tf.placeholder("float", [None, n_input]) 
y = tf.placeholder("float", [None, n_classes]) 

# weights layer 1 
h = tf.Variable(tf.random_normal([n_input, n_hidden_1])) # bias layer 1 
bias_layer_1 = tf.Variable(tf.random_normal([n_hidden_1])) 
# layer 1 layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, h), bias_layer_1)) 

# weights layer 2 
w = tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])) 

# bias layer 2 
bias_layer_2 = tf.Variable(tf.random_normal([n_hidden_2])) 

# layer 2 
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, w), bias_layer_2)) 

# weights output layer 
output = tf.Variable(tf.random_normal([n_hidden_2, n_classes])) 

# biar output layer 
bias_output = tf.Variable(tf.random_normal([n_classes])) # output layer 
output_layer = tf.matmul(layer_2, output) + bias_output

# cost function 
cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
   logits = output_layer, labels = y)) 

#cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(output_layer, y)) 
# optimizer 
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost) 

# optimizer = tf.train.GradientDescentOptimizer(
   learning_rate = learning_rate).minimize(cost) 

# Plot settings 
avg_set = [] 
epoch_set = [] 

# Initializing the variables 
init = tf.global_variables_initializer() 

# Launch the graph 
with tf.Session() as sess: 
   sess.run(init) 
   
   # Training cycle
   for epoch in range(training_epochs): 
      avg_cost = 0. 
      total_batch = int(mnist.train.num_examples / batch_size) 
      
      # Loop over all batches 
      for i in range(total_batch): 
         batch_xs, batch_ys = mnist.train.next_batch(batch_size) 
         # Fit training using batch data sess.run(optimizer, feed_dict = {
            x: batch_xs, y: batch_ys}) 
         # Compute average loss 
         avg_cost += sess.run(cost, feed_dict = {x: batch_xs, y: batch_ys}) / total_batch
      # Display logs per epoch step 
      if epoch % display_step == 0: 
         print 
         Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost)
      avg_set.append(avg_cost) 
      epoch_set.append(epoch + 1)
   print 
   "Training phase finished" 
   
   plt.plot(epoch_set, avg_set, 'o', label = 'MLP Training phase') 
   plt.ylabel('cost') 
   plt.xlabel('epoch') 
   plt.legend() 
   plt.show() 
   
   # Test model 
   correct_prediction = tf.equal(tf.argmax(output_layer, 1), tf.argmax(y, 1)) 
   
   # Calculate accuracy 
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) 
   print 
   "Model Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels})

บรรทัดโค้ดด้านบนสร้างผลลัพธ์ต่อไปนี้ -

ในบทนี้เราจะมุ่งเน้นไปที่เครือข่ายที่เราจะต้องเรียนรู้จากชุดของจุดที่รู้จักเรียกว่า x และ f (x) เลเยอร์เดียวที่ซ่อนอยู่จะสร้างเครือข่ายที่เรียบง่ายนี้

รหัสสำหรับคำอธิบายของชั้นที่ซ่อนอยู่ของ perceptron มีดังที่แสดงด้านล่าง -

#Importing the necessary modules 
import tensorflow as tf 
import numpy as np 
import math, random 
import matplotlib.pyplot as plt 

np.random.seed(1000) 
function_to_learn = lambda x: np.cos(x) + 0.1*np.random.randn(*x.shape) 
layer_1_neurons = 10 
NUM_points = 1000 

#Training the parameters 
batch_size = 100 
NUM_EPOCHS = 1500 

all_x = np.float32(np.random.uniform(-2*math.pi, 2*math.pi, (1, NUM_points))).T 
   np.random.shuffle(all_x) 

train_size = int(900) 
#Training the first 700 points in the given set x_training = all_x[:train_size] 
y_training = function_to_learn(x_training)

#Training the last 300 points in the given set x_validation = all_x[train_size:] 
y_validation = function_to_learn(x_validation) 

plt.figure(1) 
plt.scatter(x_training, y_training, c = 'blue', label = 'train') 
plt.scatter(x_validation, y_validation, c = 'pink', label = 'validation') 
plt.legend() 
plt.show()

X = tf.placeholder(tf.float32, [None, 1], name = "X")
Y = tf.placeholder(tf.float32, [None, 1], name = "Y")

#first layer 
#Number of neurons = 10 
w_h = tf.Variable(
   tf.random_uniform([1, layer_1_neurons],\ minval = -1, maxval = 1, dtype = tf.float32)) 
b_h = tf.Variable(tf.zeros([1, layer_1_neurons], dtype = tf.float32)) 
h = tf.nn.sigmoid(tf.matmul(X, w_h) + b_h)

#output layer 
#Number of neurons = 10 
w_o = tf.Variable(
   tf.random_uniform([layer_1_neurons, 1],\ minval = -1, maxval = 1, dtype = tf.float32)) 
b_o = tf.Variable(tf.zeros([1, 1], dtype = tf.float32)) 

#build the model 
model = tf.matmul(h, w_o) + b_o 

#minimize the cost function (model - Y) 
train_op = tf.train.AdamOptimizer().minimize(tf.nn.l2_loss(model - Y)) 

#Start the Learning phase 
sess = tf.Session() sess.run(tf.initialize_all_variables()) 

errors = [] 
for i in range(NUM_EPOCHS): 
   for start, end in zip(range(0, len(x_training), batch_size),\ 
      range(batch_size, len(x_training), batch_size)): 
      sess.run(train_op, feed_dict = {X: x_training[start:end],\ Y: y_training[start:end]})
   cost = sess.run(tf.nn.l2_loss(model - y_validation),\ feed_dict = {X:x_validation}) 
   errors.append(cost) 
   
   if i%100 == 0: 
      print("epoch %d, cost = %g" % (i, cost)) 
      
plt.plot(errors,label='MLP Function Approximation') plt.xlabel('epochs') 
plt.ylabel('cost') 
plt.legend() 
plt.show()

เอาต์พุต

ต่อไปนี้เป็นตัวแทนของการประมาณชั้นฟังก์ชัน -

ที่นี่ข้อมูลสองรายการแสดงในรูปของ W. ข้อมูลทั้งสองคือรถไฟและการตรวจสอบความถูกต้องซึ่งแสดงด้วยสีที่แตกต่างกันตามที่ปรากฏในส่วนตำนาน

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

เครื่องมือเพิ่มประสิทธิภาพพื้นฐานของ TensorFlow คือ -

tf.train.Optimizer

คลาสนี้ถูกกำหนดไว้ในพา ธ ที่ระบุของ tensorflow / python / training / optimizer.py

ต่อไปนี้เป็นเครื่องมือเพิ่มประสิทธิภาพบางส่วนใน Tensorflow -

Stochastic Gradient โคตร
Stochastic ไล่ระดับสีด้วยการตัดแบบไล่ระดับ
Momentum
โมเมนตัม Nesterov
Adagrad
Adadelta
RMSProp
Adam
Adamax
SMORMS3

เราจะเน้นโคตร Stochastic Gradient ภาพประกอบสำหรับการสร้างเครื่องมือเพิ่มประสิทธิภาพสำหรับสิ่งเดียวกันมีดังต่อไปนี้ -

def sgd(cost, params, lr = np.float32(0.01)):
   g_params = tf.gradients(cost, params)
   updates = []
   
   for param, g_param in zip(params, g_params):
      updates.append(param.assign(param - lr*g_param))
   return updates

พารามิเตอร์พื้นฐานถูกกำหนดไว้ภายในฟังก์ชันเฉพาะ ในบทต่อไปเราจะมุ่งเน้นไปที่การเพิ่มประสิทธิภาพการไล่ระดับสีด้วยการใช้เครื่องมือเพิ่มประสิทธิภาพ

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

ก	ข	ก XOR ข
0	0	0
0	1	1
1	0	1
1	1	0

โดยทั่วไปแล้ววิธีการเข้ารหัส XOR Cipher นั้นใช้ในการเข้ารหัสข้อมูลซึ่งยากที่จะถอดรหัสด้วยวิธี brute force กล่าวคือโดยการสร้างคีย์การเข้ารหัสแบบสุ่มซึ่งตรงกับคีย์ที่เหมาะสม

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

#Declaring necessary modules
import tensorflow as tf
import numpy as np
"""
A simple numpy implementation of a XOR gate to understand the backpropagation
algorithm
"""

x = tf.placeholder(tf.float64,shape = [4,2],name = "x")
#declaring a place holder for input x
y = tf.placeholder(tf.float64,shape = [4,1],name = "y")
#declaring a place holder for desired output y

m = np.shape(x)[0]#number of training examples
n = np.shape(x)[1]#number of features
hidden_s = 2 #number of nodes in the hidden layer
l_r = 1#learning rate initialization

theta1 = tf.cast(tf.Variable(tf.random_normal([3,hidden_s]),name = "theta1"),tf.float64)
theta2 = tf.cast(tf.Variable(tf.random_normal([hidden_s+1,1]),name = "theta2"),tf.float64)

#conducting forward propagation
a1 = tf.concat([np.c_[np.ones(x.shape[0])],x],1)
#the weights of the first layer are multiplied by the input of the first layer

z1 = tf.matmul(a1,theta1)
#the input of the second layer is the output of the first layer, passed through the 
   activation function and column of biases is added

a2 = tf.concat([np.c_[np.ones(x.shape[0])],tf.sigmoid(z1)],1)
#the input of the second layer is multiplied by the weights

z3 = tf.matmul(a2,theta2)
#the output is passed through the activation function to obtain the final probability

h3 = tf.sigmoid(z3)
cost_func = -tf.reduce_sum(y*tf.log(h3)+(1-y)*tf.log(1-h3),axis = 1)

#built in tensorflow optimizer that conducts gradient descent using specified 
   learning rate to obtain theta values

optimiser = tf.train.GradientDescentOptimizer(learning_rate = l_r).minimize(cost_func)

#setting required X and Y values to perform XOR operation
X = [[0,0],[0,1],[1,0],[1,1]]
Y = [[0],[1],[1],[0]]

#initializing all variables, creating a session and running a tensorflow session
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

#running gradient descent for each iteration and printing the hypothesis 
   obtained using the updated theta values
for i in range(100000):
   sess.run(optimiser, feed_dict = {x:X,y:Y})#setting place holder values using feed_dict
   if i%100==0:
      print("Epoch:",i)
      print("Hyp:",sess.run(h3,feed_dict = {x:X,y:Y}))

บรรทัดด้านบนของโค้ดจะสร้างผลลัพธ์ตามที่แสดงในภาพหน้าจอด้านล่าง -

การเพิ่มประสิทธิภาพแบบไล่ระดับสีถือเป็นแนวคิดที่สำคัญในวิทยาศาสตร์ข้อมูล

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

ขั้นตอนที่ 1

รวมโมดูลที่จำเป็นและการประกาศตัวแปร x และ y ซึ่งเราจะกำหนดการเพิ่มประสิทธิภาพการไล่ระดับสี

import tensorflow as tf

x = tf.Variable(2, name = 'x', dtype = tf.float32)
log_x = tf.log(x)
log_x_squared = tf.square(log_x)

optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(log_x_squared)

ขั้นตอนที่ 2

เริ่มต้นตัวแปรที่จำเป็นและเรียกเครื่องมือเพิ่มประสิทธิภาพเพื่อกำหนดและเรียกใช้ด้วยฟังก์ชันที่เกี่ยวข้อง

init = tf.initialize_all_variables()

def optimize():
   with tf.Session() as session:
      session.run(init)
      print("starting at", "x:", session.run(x), "log(x)^2:", session.run(log_x_squared))
      
      for step in range(10):
         session.run(train)
         print("step", step, "x:", session.run(x), "log(x)^2:", session.run(log_x_squared))
optimize()

บรรทัดด้านบนของโค้ดจะสร้างผลลัพธ์ตามที่แสดงในภาพหน้าจอด้านล่าง -

เราจะเห็นได้ว่ามีการคำนวณยุคและการทำซ้ำที่จำเป็นดังแสดงในผลลัพธ์

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

สมมติว่ามีบ่อน้ำขนาด 500 * 500 ตาราง -

N = 500

ตอนนี้เราจะคำนวณสมการเชิงอนุพันธ์ย่อยและสร้างกราฟตามลำดับโดยใช้มัน พิจารณาขั้นตอนด้านล่างสำหรับการคำนวณกราฟ

Step 1 - นำเข้าห้องสมุดเพื่อการจำลอง

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

Step 2 - รวมฟังก์ชันสำหรับการแปลงอาร์เรย์ 2D เป็นเคอร์เนล Convolution และการดำเนินการ Convolution 2D ที่เรียบง่าย

def make_kernel(a):
   a = np.asarray(a)
   a = a.reshape(list(a.shape) + [1,1])
   return tf.constant(a, dtype=1)

def simple_conv(x, k):
   """A simplified 2D convolution operation"""
   x = tf.expand_dims(tf.expand_dims(x, 0), -1)
   y = tf.nn.depthwise_conv2d(x, k, [1, 1, 1, 1], padding = 'SAME')
   return y[0, :, :, 0]

def laplace(x):
   """Compute the 2D laplacian of an array"""
   laplace_k = make_kernel([[0.5, 1.0, 0.5], [1.0, -6., 1.0], [0.5, 1.0, 0.5]])
   return simple_conv(x, laplace_k)
   
sess = tf.InteractiveSession()

Step 3 - รวมจำนวนการทำซ้ำและคำนวณกราฟเพื่อแสดงบันทึกตามนั้น

N = 500

# Initial Conditions -- some rain drops hit a pond

# Set everything to zero
u_init = np.zeros([N, N], dtype = np.float32)
ut_init = np.zeros([N, N], dtype = np.float32)

# Some rain drops hit a pond at random points
for n in range(100):
   a,b = np.random.randint(0, N, 2)
   u_init[a,b] = np.random.uniform()

plt.imshow(u_init)
plt.show()

# Parameters:
# eps -- time resolution
# damping -- wave damping
eps = tf.placeholder(tf.float32, shape = ())
damping = tf.placeholder(tf.float32, shape = ())

# Create variables for simulation state
U = tf.Variable(u_init)
Ut = tf.Variable(ut_init)

# Discretized PDE update rules
U_ = U + eps * Ut
Ut_ = Ut + eps * (laplace(U) - damping * Ut)

# Operation to update the state
step = tf.group(U.assign(U_), Ut.assign(Ut_))

# Initialize state to initial conditions
tf.initialize_all_variables().run()

# Run 1000 steps of PDE
for i in range(1000):
   # Step simulation
   step.run({eps: 0.03, damping: 0.04})
   
   # Visualize every 50 steps
   if i % 500 == 0:
      plt.imshow(U.eval())
      plt.show()

กราฟถูกพล็อตตามที่แสดงด้านล่าง -

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

โครงสร้างโฟลเดอร์ของการใช้รหัสการจดจำรูปภาพมีดังที่แสดงด้านล่าง -

dataset_image มีรูปภาพที่เกี่ยวข้องซึ่งจำเป็นต้องโหลด เราจะเน้นไปที่การจดจำรูปภาพโดยมีโลโก้ของเรากำหนดไว้ในนั้น รูปภาพจะโหลดด้วยสคริปต์“ load_data.py” ซึ่งช่วยในการจดบันทึกเกี่ยวกับโมดูลการจดจำรูปภาพต่างๆ

import pickle
from sklearn.model_selection import train_test_split
from scipy import misc

import numpy as np
import os

label = os.listdir("dataset_image")
label = label[1:]
dataset = []

for image_label in label:
   images = os.listdir("dataset_image/"+image_label)
   
   for image in images:
      img = misc.imread("dataset_image/"+image_label+"/"+image)
      img = misc.imresize(img, (64, 64))
      dataset.append((img,image_label))
X = []
Y = []

for input,image_label in dataset:
   X.append(input)
   Y.append(label.index(image_label))

X = np.array(X)
Y = np.array(Y)

X_train,y_train, = X,Y

data_set = (X_train,y_train)

save_label = open("int_to_word_out.pickle","wb")
pickle.dump(label, save_label)
save_label.close()

การฝึกอบรมภาพช่วยในการจัดเก็บรูปแบบที่เป็นที่รู้จักภายในโฟลเดอร์ที่ระบุ

import numpy
import matplotlib.pyplot as plt

from keras.layers import Dropout
from keras.layers import Flatten
from keras.constraints import maxnorm
from keras.optimizers import SGD
from keras.layers import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils
from keras import backend as K

import load_data
from keras.models import Sequential
from keras.layers import Dense

import keras
K.set_image_dim_ordering('tf')

# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)

# load data
(X_train,y_train) = load_data.data_set

# normalize inputs from 0-255 to 0.0-1.0
X_train = X_train.astype('float32')

#X_test = X_test.astype('float32')
X_train = X_train / 255.0

#X_test = X_test / 255.0
# one hot encode outputs
y_train = np_utils.to_categorical(y_train)

#y_test = np_utils.to_categorical(y_test)
num_classes = y_train.shape[1]

# Create the model
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), padding = 'same', 
   activation = 'relu', kernel_constraint = maxnorm(3)))

model.add(Dropout(0.2))
model.add(Conv2D(32, (3, 3), activation = 'relu', padding = 'same', 
   kernel_constraint = maxnorm(3)))

model.add(MaxPooling2D(pool_size = (2, 2)))
model.add(Flatten())
model.add(Dense(512, activation = 'relu', kernel_constraint = maxnorm(3)))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation = 'softmax'))

# Compile model
epochs = 10
lrate = 0.01
decay = lrate/epochs
sgd = SGD(lr = lrate, momentum = 0.9, decay = decay, nesterov = False)
model.compile(loss = 'categorical_crossentropy', optimizer = sgd, metrics = ['accuracy'])
print(model.summary())

#callbacks = [keras.callbacks.EarlyStopping(
   monitor = 'val_loss', min_delta = 0, patience = 0, verbose = 0, mode = 'auto')]
callbacks = [keras.callbacks.TensorBoard(log_dir='./logs', 
   histogram_freq = 0, batch_size = 32, write_graph = True, write_grads = False, 
   write_images = True, embeddings_freq = 0, embeddings_layer_names = None, 
   embeddings_metadata = None)]

# Fit the model

model.fit(X_train, y_train, epochs = epochs, 
   batch_size = 32,shuffle = True,callbacks = callbacks)

# Final evaluation of the model
scores = model.evaluate(X_train, y_train, verbose = 0)
print("Accuracy: %.2f%%" % (scores[1]*100))

# serialize model to JSONx
model_json = model.to_json()
with open("model_face.json", "w") as json_file:
   json_file.write(model_json)

# serialize weights to HDF5
model.save_weights("model_face.h5")
print("Saved model to disk")

บรรทัดด้านบนของโค้ดจะสร้างผลลัพธ์ดังที่แสดงด้านล่าง -

ในบทนี้เราจะทำความเข้าใจเกี่ยวกับแง่มุมต่างๆของการฝึกอบรมเครือข่ายประสาทเทียมซึ่งสามารถดำเนินการได้โดยใช้กรอบ TensorFlow

ต่อไปนี้เป็นคำแนะนำ 10 ข้อซึ่งสามารถประเมินได้ -

กลับการขยายพันธุ์

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

Stochastic Gradient Descent

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