บทนำสู่ Quantum Machine Learning

ภาพรวมและแรงจูงใจ

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

Note: This survey is provided by IBM Quantum and relates to the original English content. To give feedback on doQumentation's website, translations, or code execution, please open a GitHub issue.

ยินดีต้อนรับสู่ quantum machine learning!

วิดีโอด้านล่างจะให้บทนำสั้นๆ ที่เสริมด้วยข้อความด้านล่าง

เพื่อสรุปและเสริมวิดีโออย่างย่อ:

• เราได้เห็นปัญหาที่ได้รับการแก้ไขเป็นครั้งแรกบนคอมพิวเตอร์ควอนตัม จากนั้นผู้คนก็หาวิธีทำบน classical supercomputer ได้ วงจรของ classical และ quantum computing ที่ผลักดันกันไปจนถึงขีดจำกัดนี้น่าจะดำเนินต่อไปอีกสักสองสามปี
• มีปัญหาเฉพาะที่ quantum computing สามารถมีข้อได้เปรียบที่พิสูจน์ได้เหนือ classical computing โดยขึ้นอยู่กับความก้าวหน้าในด้านต่างๆ เช่น การลดข้อผิดพลาดและจำนวน Qubit ที่มี แต่นี่ยังคงเป็นช่วงเวลาของการสำรวจ ค้นหาชุดข้อมูลที่เหมาะกับควอนตัมและ quantum feature maps ที่มีประโยชน์
• Quantum machine learning (QML) เป็นหนึ่งในหลายพื้นที่น่าตื่นเต้นที่ quantum computing สามารถเสริมหรือเติมเต็ม workflow แบบ classical ที่มีอยู่

Machine learning (ML) ใช้อัลกอริทึมกับชุดข้อมูล ดังนั้น QML อาจรวม quantum mechanics ในด้านข้อมูลหรืออัลกอริทึม หรือทั้งสองอย่าง ความเป็นไปได้ทั้งหมดนี้อาจน่าสนใจ แต่เราส่วนใหญ่จะจำกัดตัวเองในการอภิปรายเกี่ยวกับ quantum algorithms ที่ใช้กับข้อมูล classical เหตุผลหนึ่งคือปัญหา ML ที่มีข้อมูล classical ได้รับการศึกษาและมีให้ใช้งานอย่างแพร่หลายแล้ว มีความสนใจอย่างกว้างขวางในการแก้ปัญหาที่เริ่มต้นด้วยข้อมูล classical อีกเหตุผลหนึ่งคือการขาด QRAM หากไม่มีความสามารถในการจัดเก็บข้อมูลควอนตัมจำนวนมากในระยะเวลาที่ยาวนานพอสมควร วิธีการที่เริ่มต้นด้วยข้อมูลควอนตัมยังค่อนข้างห่างไกลจากการใช้งานจริงในอุตสาหกรรม นอกจากนี้ยังไม่ชัดเจนว่าจะ "เข้าถึงข้อมูล classical แบบ quantum" ได้อย่างมีประสิทธิภาพอย่างไร ML สองประเภทที่น่าสนใจโดยเฉพาะคือ supervised learning ที่คุณฝึกอัลกอริทึมโดยใช้ชุดข้อมูลที่มีป้ายกำกับ และ unsupervised learning ที่อัลกอริทึมพยายามเรียนรู้เกี่ยวกับการกระจายตัวจากตัวอย่างที่ไม่มีป้ายกำกับ อัลกอริทึม unsupervised อาจเรียนรู้วิธีสร้างตัวอย่างใหม่จากการกระจายตัวเดิม หรือวิธีจัดกลุ่มตัวอย่างเป็นกลุ่มที่มีลักษณะคล้ายกัน

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

ผู้ที่มีพื้นฐาน machine learning จะรู้ดีอยู่แล้วว่าวิธีการแก้ปัญหาหลายอย่างเกี่ยวข้องกับการ mapping ข้อมูลไปยังพื้นที่มิติสูง ซึ่งได้รับการสำรวจเป็นอย่างดีโดยเฉพาะในบริบทของ kernels เพื่อเป็นการเตือนความจำอย่างย่อ บางครั้งข้อมูลอาจแยกออกเป็นหมวดหมู่ได้ด้วยเส้นตรง ระนาบ หรือ hyperplane (เราจะพูดว่า "hyperplane" อย่างย่อบ่อยๆ) ในจำนวนมิติเดิมที่ข้อมูลถูกให้มา ซึ่งแสดงในภาพแรกด้านบน ในบางครั้ง ข้อมูลอาจไม่สามารถแยกด้วย hyperplane ในมิตินั้นได้ ดังที่แสดงในภาพที่สอง แต่ก็ยังอาจมีโครงสร้างในข้อมูลที่สามารถใช้ประโยชน์ใน mapping ไปยังมิติที่สูงกว่าซึ่งทำให้ข้อมูลสามารถแยกได้ในพื้นที่มิติสูงนั้น ดังที่แสดงใน mapping ของข้อมูล 2D ที่มีสมมาตรวงกลมไปยังพื้นที่ 3D ที่จุดข้อมูลถูกจัดเรียงบนพื้นผิว paraboloid

เป้าหมายทั่วไปใน QML คือการหา mapping จากชุด features มิติต่ำกว่าไปยังพื้นที่มิติสูงกว่า ที่แยกจุดข้อมูลของเราได้อย่างมีประสิทธิภาพ เพื่อที่เราจะใช้ mapping นั้นในการจำแนกจุดข้อมูลใหม่ แต่นี่ไม่ใช่งานที่ง่าย และการอภิปรายเกี่ยวกับประโยชน์ที่อาจเกิดขึ้นของ quantum computing ใน machine learning ต้องมาพร้อมกับข้อแม้ที่เหมาะสม โดยเฉพาะอย่างยิ่ง เราต้องจัดการกับความละเอียดอ่อนในการเลือกชุดข้อมูลและความท้าทายในการบรรลุ utility scale นอกจากนี้เรายังต้องเปลี่ยนจากการพยายามเหนือกว่าอัลกอริทึม classical ML บนข้อมูลที่ classical algorithms จัดการได้อย่างมีประสิทธิภาพและดีอยู่แล้ว และเน้นการอภิปรายไปที่การสำรวจ feature maps ใหม่ที่อาจมีประโยชน์

การจัดการความคาดหวัง

ชุดข้อมูลจำนวนมากที่ใช้ในแอปพลิเคชัน QML ที่อธิบายในวรรณกรรมนั้น "feature engineered" หมายความว่าชุดข้อมูลถูกเลือกหรือสร้างขึ้นโดยเฉพาะเพื่อแสดงกรณีการใช้งานแคบๆ ที่ quantum computing มีประโยชน์ ถ้าดูเหมือนโกงก็แสดงว่าเราเข้าใจงานผิด ไม่ใช่ว่า quantum feature maps บางอย่างทำให้เราแก้งาน classification ทั้งหมดหรือหลายอย่างได้อย่างมีประสิทธิภาพหรือสเกลได้มากกว่า classical machine learning algorithms แต่ quantum feature maps บางอย่าง (ไม่ใช่ทั้งหมด) ทำงานแตกต่างจาก classical feature maps งานที่ต้องทำคือสำรวจ quantum circuits ในบริบทของโครงสร้างข้อมูลที่ซับซ้อน คำถามเฉพาะบางอย่างที่ต้องจัดการคือ:

1. quantum circuits ใดมีแนวโน้มสูงสุดที่จะทำงานในรูปแบบใหม่เมื่อเทียบกับทางเลือก classical?
2. มีปัญหาในโลกจริงที่เกี่ยวข้องกับข้อมูลที่มีคุณสมบัติที่สำรวจได้ดีที่สุดโดยใช้ quantum circuits ใหม่ดังกล่าวหรือไม่?
3. quantum circuits เหล่านี้สเกลบนคอมพิวเตอร์ควอนตัม near-term ได้หรือไม่?

คำอธิบายที่ไม่เพียงพอ

บ่อยครั้งที่คนพบคำอธิบายแบบง่ายว่า quantum computing สามารถทรงพลังได้อย่างไร ซึ่งฟังดูประมาณนี้:

เช่นเดียวกับที่คอมพิวเตอร์แบบ classical ใช้บิตของข้อมูล คอมพิวเตอร์ควอนตัมใช้ Qubit เมื่อมีบิตจำนวนหนึ่ง สมมติ 4 บิต คอมพิวเตอร์แบบ classical สามารถอยู่ใน state ใด state หนึ่งจาก $2^4 = 16$ states ที่เป็นไปได้ ในขณะที่คอมพิวเตอร์ควอนตัมสามารถอยู่ใน superposition ของทั้ง 16 states พร้อมกัน และสามารถดำเนินการกับ superposition ทั้งหมดนี้ได้ ในบางกรณี สิ่งนี้ทำให้เราสามารถออกแบบอัลกอริทึมการเรียนรู้ที่น่าสนใจตามการ mapping ไปยังพื้นที่มิติสูง

นี่เป็นข้อความที่เป็นความจริง แต่ยังไม่เพียงพอและค่อนข้างทำให้เข้าใจผิดดังที่เราจะอธิบาย นอกจากนี้ยังพบการเน้นความแตกต่างระหว่าง complex และ real coefficients เช่น:

ระบบ probabilistic แบบ classical ที่ระบบสามารถอธิบายว่ามีความน่าจะเป็นบางอย่างที่อยู่ใน states ต่างๆ สามารถอธิบายได้ดังนี้

$$|s\rangle = a|0000\rangle+b|0001\rangle+c|0010\rangle+... a, b, c \in \reals$$

ในระบบดังกล่าว coefficients $a$, $b$, $c$ และอื่นๆ สามารถมีความหมายได้ก็ต่อเมื่อเป็นจำนวนจริงบวก States ในคอมพิวเตอร์ควอนตัมถูกอธิบายด้วย probability amplitudes ที่เป็นจำนวนเชิงซ้อนได้

$$|\psi \rangle = A|0000\rangle+B|0001\rangle+C|0010\rangle+... A, B, C \in \mathbb{C}$$

ข้อความข้างต้นถูกระบุอย่างระมัดระวังมากจนเป็นความจริง (คำพูดผิวเผินจำนวนมากไม่ถูกต้อง) แต่ข้อความที่ถูกต้องเหล่านี้ไม่ใช่คำอธิบายของพลังของ quantum computing ใน machine learning ประการหนึ่ง การใช้ quantum computing กับ machine learning จะเกี่ยวข้องกับการวัดและเราไม่สามารถวัด Qubit ให้อยู่ใน multiple states พร้อมกัน เราสามารถเตรียม Qubit ใน superposition เช่น $|\psi\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$ แต่การวัดจะให้ผล $|0\rangle$ หรือ $|1\rangle$ ดังนั้น อย่างน้อยที่สุด เรื่องราวเกี่ยวกับการเพิ่มมิตินี้ยังไม่สมบูรณ์ นอกจากนี้ ในบริบทของ kernels มิติที่เพิ่มขึ้นใน quantum computing ไม่สามารถเป็นเงื่อนไขที่เพียงพอสำหรับพลังการคำนวณเหนือทางเลือก classical เนื่องจาก Gaussian kernels มีมิติอนันต์ มีรายละเอียดที่ละเอียดอ่อนอยู่ตรงที่ Gaussian feature maps ใช้เฉพาะร่วมกับ "kernel trick" ที่หลีกเลี่ยงความจำเป็นในการคำนวณ vector ที่ mapped ไปยังมิติอนันต์ แต่ประเด็นยังคงอยู่:

ความมิติสูงของ quantum states ที่พัวพันกันไม่ใช่ parallelism แบบ exponential และไม่ใช่เงื่อนไขที่เพียงพอสำหรับพลังที่เพิ่มขึ้นใน machine learning

ในบทเรียนต่อๆ ไป เราจะนำเสนอ workflow สำหรับการรวม quantum circuits เข้าสู่งาน machine learning และเราทำเช่นนี้เพื่อวัตถุประสงค์ที่ชัดเจนในการอำนวยความสะดวกในการสำรวจพลังของ quantum computing ไม่มี feature map หรืออัลกอริทึมใดในคอร์สนี้ที่นำเสนอว่าเป็นเส้นทางด่วนไปสู่ผลลัพธ์ machine learning ที่ดีกว่าสำหรับปัญหาทั่วไป เพราะ feature map หรืออัลกอริทึมดังกล่าวไม่มีอยู่จริง แต่เรานำเสนอเครื่องมือ quantum ที่หลากหลายเพื่อใช้ในการสำรวจ quantum computing ที่มีประโยชน์

Dequantization

Dequantization หมายถึงการแทนที่ quantum algorithm ที่กำหนดด้วย classical algorithm ที่ทำงานได้คล้ายกับ quantum algorithm สำหรับชุดงานที่กำหนด ซึ่งโดยทั่วไปรวมถึงการสเกล ตามนิยามบางอย่าง classical algorithm ควรทำงานช้ากว่า quantum algorithm เพียง polynomial เท่านั้น

อัลกอริทึม quantum machine learning (QML) หลายตัวที่เดิมคิดว่าจะให้ speedup อย่างมีนัยสำคัญเหนือ classical algorithms ได้ถูก dequantize ในช่วงไม่กี่ปีที่ผ่านมา กระบวนการ dequantization นี้นำไปสู่ข้อมูลเชิงลึกที่สำคัญเกี่ยวกับข้อได้เปรียบที่อาจเกิดขึ้นและข้อจำกัดของแนวทาง quantum ต่อ machine learning

หนึ่งในผลลัพธ์ dequantization ที่โดดเด่นที่สุดมาจากผลงานของ Ewin Tang เกี่ยวกับระบบ recommendation Tang ค้นพบ classical algorithm ที่สามารถทำงาน recommendation ด้วยความเร็วที่เดิมคิดว่าทำได้เฉพาะด้วยคอมพิวเตอร์ควอนตัมเท่านั้น การค้นพบนี้ท้าทายสมมติฐานที่ว่า quantum algorithms มีข้อได้เปรียบแบบ exponential สำหรับปัญหานี้ ผลงานล่าสุดโดย Shin et al. มุ่งเน้นที่การระบุเงื่อนไขบน dequantizability ของ function class ของโมเดล variational quantum machine learning

แนวทางทั่วไปอย่างหนึ่งในการ dequantization (แม้ไม่ใช่เทคนิคเดียว) คือการพิจารณา overhead ของการโหลดข้อมูล นั่นคือ quantum algorithm ใดๆ ที่ใช้กับข้อมูล classical จะมีขั้นตอนที่ข้อมูล classical ถูก encode เข้าสู่คอมพิวเตอร์ควอนตัม ถ้า quantum algorithm ถือว่าเริ่มต้นจากจุดที่ข้อมูลควอนตัมพร้อมใช้งานแล้ว ก็ถือว่าซ่อนเวลาที่จำเป็นสำหรับการ encoding บางกรณีของ dequantization ได้แสดงให้เห็นว่าเมื่อรวมเวลา encoding นี้ และเมื่อการโหลดข้อมูล classical สามารถทำได้อย่างมีประสิทธิภาพ quantum algorithm ก็ไม่สามารถเหนือกว่า classical counterpart ได้อีกต่อไป

แม้ว่าอัลกอริทึมจะไม่สามารถ dequantize ได้ก็ไม่ได้หมายความว่ามันมีประสิทธิภาพหรือสเกลได้ดีกว่า classical algorithms ทั้งหมด ลองนึกถึงตัวอย่างสุดขีดที่แต่งขึ้น: จินตนาการถึงอัลกอริทึมสำหรับเลือก j elements ที่ใหญ่ที่สุดจากชุดขนาด k เราสามารถเขียน quantum algorithm ที่ใช้ Shor's algorithm ในการแยกตัวประกอบของแต่ละใน k elements เป็นตัวประกอบเฉพาะ จากนั้นระบุ elements ที่ใหญ่ที่สุดโดยใช้ตัวประกอบเฉพาะ อัลกอริทึมดังกล่าวน่าจะไม่สามารถ dequantize ได้ แต่มีประสิทธิภาพน้อยกว่า classical algorithms อย่างมากในการทำงานเดียวกันในการเลือก elements ที่ใหญ่ที่สุด (แม้ว่าไม่ใช่ส่วนการแยกตัวประกอบที่ไม่จำเป็น)

หลักฐานว่ามีอยู่จริง

ในปี 2021 นักวิจัย IBM Quantum® Yunchao Liu, Srinivasan Arunachalam และ Kristan Temme ได้ตีพิมพ์บทความใน Nature, A rigorous and robust quantum speed-up in supervised machine learning. สอดคล้องกับข้อแม้ข้างต้น ปัญหา classification ถูกเลือกอย่างรอบคอบสำหรับงานนี้ที่ (1) ทราบว่ายากสำหรับ classical และ (2) เหมาะกับ quantum algorithms ที่จะแสดง speedup

บทความนี้จัดการกับการจำแนกข้อมูลตาม discrete logarithms อ้างอิงจากบทความว่า "สำหรับ prime number $p$ ขนาดใหญ่และ generator $g$ ของ $\mathbb{Z}^*_p = {1, 2, . . . , p − 1}$ เป็นสมมติฐานที่เชื่อกันอย่างแพร่หลายว่าไม่มี classical algorithm ที่สามารถคำนวณ $\text{log}_g(x)$ บน input $x \in \mathbb{Z}^*_p$ ในเวลา polynomial ใน $n = \lceil{\text{log}_2(p)}\rceil$ จำนวนบิตที่จำเป็นในการแทนค่า $p$" ในทางตรงกันข้าม Shor's algorithm ทราบกันดีว่าแก้ปัญหา discrete log ใน polynomial time การเลือกปัญหานี้จึงตอบสนองเกณฑ์ข้างต้นพร้อมกัน: ความยากแบบ classical (ไม่น่า dequantize ได้) และทราบว่าเหมาะกับ quantum algorithms

ผ่านการเลือกปัญหา classification อย่างรอบคอบนี้ ผู้เขียนสามารถแสดงให้เห็น exponential speedup โดยใช้ quantum kernel methods (สรุปสั้นๆ ด้านล่างและอภิปรายในบทเรียนต่อมา) ที่ทั้ง end-to-end และ robust ที่นี่ "end-to-end" หมายถึงสมมติฐานเกี่ยวกับการเริ่มต้นด้วยข้อมูล classical ผู้เขียนในกรณีนี้รวมเวลาสำหรับ data encoding ด้วย ที่นี่ "robust" หมายถึงข้อเท็จจริงที่ว่าข้อมูลที่จะจำแนกถูกแยกด้วย margin กว้างโดยใช้ quantum algorithm ทำให้ความสำเร็จของ classification มีความทนทานต่อการพิจารณาในโลกจริงเช่น finite sampling error

ทั้งหมดนี้หมายความว่าปัญหาที่ quantum kernels สามารถให้ exponential speedup มีอยู่จริง แต่สถานะปัจจุบันของวิทยาศาสตร์คือปัญหาดังกล่าวถูกเลือกตามการสังเกตหรือเหตุผลทางทฤษฎีว่าควรเหมาะกับ quantum algorithms ไม่สมจริงที่จะคาดหวัง quantum speedup สำหรับงาน machine learning ที่คอมพิวเตอร์ classical ทำได้ค่อนข้างดีอยู่แล้ว

การระบุกรณีที่เหมาะสมสำหรับการสำรวจ quantum utility เป็นความรับผิดชอบอย่างมากสำหรับผู้เรียนในคอร์สนี้ และไม่ใช่งานที่สามารถทำสำเร็จในคอร์สเช่นนี้ การสำรวจนั้นเป็นงานของ IBM Quantum Network ทั้งหมด ที่ประกอบด้วยนักวิจัยเช่นคุณเอง คอร์สนี้จะสาธิต QML workflow และกลยุทธ์การ encoding เพื่อให้คุณสามารถเริ่มสำรวจ quantum utility ในด้านความเชี่ยวชาญของคุณเอง

เราหวังว่าบทนำนี้จะทำให้สิ่งต่างๆ เกี่ยวกับ quantum machine learning ชัดเจนขึ้น:

1. Quantum algorithms สามารถให้ exponential speedup เหนือ classical algorithms สำหรับปัญหาเฉพาะมากที่ยากสำหรับ classical และเหมาะกับ quantum algorithms
2. ความมิติสูงของ entangled states ใน quantum computing มีความสำคัญ แต่ไม่เพียงพอที่จะได้เปรียบเหนือ classical algorithms โดยง่าย
3. การหาปัญหาที่เหมาะกับ quantum algorithms เป็นงานที่ยากมาก และส่วนใหญ่จะตกอยู่กับผู้เรียนในคอร์สนี้

คำถามตรวจสอบความเข้าใจ

อะไรทำให้ quantum states แตกต่างจาก classical states?

คำตอบ:

หลายอย่าง โดยเฉพาะ: complex coefficients และ superposition ด้วยสำเนาเดียว มีความแตกต่างอื่นๆ อีกมากที่จะอภิปรายในบทเรียนต่อๆ ไป รวมถึง entanglement และ interference

จริงหรือเท็จ? Quantum states ที่พัวพันกันสูงทำให้เราแก้ปัญหา machine learning ส่วนใหญ่ได้อย่างมีประสิทธิภาพมากขึ้นบนคอมพิวเตอร์ควอนตัม

คำตอบ:

เท็จ ปัญหา machine learning ส่วนใหญ่ได้รับการแก้อย่างมีประสิทธิภาพมากโดย classical algorithms และ quantum algorithms ไม่น่าจะให้ speedup ที่มีนัยสำคัญ เป้าหมายใน QML คือการหาชุดข้อมูลที่มี features ที่อธิบายได้ดีโดย quantum states และ/หรือการหา mapping ของ data features ที่เพิ่มประสิทธิภาพความแม่นยำของโมเดล

เป้าหมายการเรียนรู้ของคอร์ส

หลังจากเรียนจบคอร์สนี้ คุณสามารถคาดหวังที่จะสร้าง core skills และ competencies ต่อไปนี้ ผู้เรียนจะสามารถ:

1. อธิบายว่า QML คืออะไรและควอนตัมเชื่อมต่อกับ classical machine learning ได้อย่างไร

2. ใช้คำศัพท์ quantum และ key terms กับ ML workflow

3. ระบุองค์ประกอบสำคัญของ QML workflow (ประเภทต่างๆ)

4. ระบุ QML ประเภทต่างๆ และแยกแยะความแตกต่างระหว่างพวกเขา

5. Implement quantum kernel methods และ variational quantum classifiers โดยใช้ Qiskit Runtime primitives และตาม Qiskit patterns

6. ระบุว่า QML มีแนวโน้มมากที่สุดที่ไหนและที่ไหนที่ไม่เป็นเช่นนั้น

7. ปรับปัญหาตัวอย่างให้เข้ากับชุดข้อมูลของตนเอง

8. ตระหนักถึงประเด็นใน QML เช่น training time, noise และ compounding error ใน multiple-state readouts

9. ให้คำแนะนำว่า QML อาจเป็นประโยชน์ต่อองค์กรของตนได้อย่างไร

โครงสร้างคอร์ส

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

ท้ายคอร์สมีแบบทดสอบ 20 ข้อ คุณต้องได้คะแนนอย่างน้อย 70% บนแบบทดสอบนี้จึงจะได้รับ Quantum Machine Learning badge ผ่าน Credly ถ้าได้อย่างน้อย 70% badge จะถูกส่งทางอีเมลให้คุณโดยอัตโนมัติไม่นานหลังจากนั้น คุณส่งแบบทดสอบได้เพียงสองครั้ง หลังจากการส่งครั้งแรก คุณจะมีโอกาสลองตอบคำถามที่ตอบผิดอีกครั้ง หลังจากการส่งครั้งที่สอง คะแนนของคุณจะเป็นขั้นสุดท้าย ดูรายละเอียดเพิ่มเติมในแบบทดสอบ

โครงสร้างคอร์สมีดังนี้:

• บทเรียน 1: บทนำและภาพรวม
• บทเรียน 2: ทบทวน machine learning
• บทเรียน 3: Data encoding
• บทเรียน 4: Quantum kernel methods และ support vector machines
• บทเรียน 5: Variational quantum classifiers / neural networks
• ข้อสอบรับ badge

รัน QML code แรกของคุณ

มักเป็นประโยชน์ที่จะเห็นว่าเรากำลังมุ่งไปที่ไหน ก่อนที่จะแยกย่อยเป็นชิ้นๆ และเจาะลึกพื้นฐาน code cells ด้านล่างดำเนินการ instance ง่ายๆ ของ quantum kernel method โดยเฉพาะอย่างยิ่ง kernel matrix element เดียวถูกคำนวณ ผู้ใช้ที่ยังใหม่กับ kernel methods หรือ quantum kernels ไม่ควรรู้สึกกลัว บทเรียนหลายบทในคอร์สนี้จะอุทิศให้กับการวิเคราะห์สิ่งที่ทำอยู่ใน cells เหล่านี้อย่างละเอียด

ด้วย code นี้เราแนะนำ Qiskit patterns พร้อมกัน: กรอบงานสำหรับการเข้าถึง quantum computing ที่ utility scale กรอบงานนี้ประกอบด้วยสี่ขั้นตอนที่ทั่วไปมากและสามารถนำไปใช้กับปัญหาส่วนใหญ่ได้ (แม้ว่าใน workflow บางอย่าง ขั้นตอนบางอย่างอาจทำซ้ำหลายครั้ง)

Qiskit patterns:

• ขั้นตอนที่ 1: Map classical inputs ไปยังปัญหา quantum
• ขั้นตอนที่ 2: Optimize ปัญหาสำหรับ quantum execution
• ขั้นตอนที่ 3: Execute โดยใช้ Qiskit Runtime Primitives
• ขั้นตอนที่ 4: วิเคราะห์ / post-processing

ใน cells ด้านล่าง เราให้คำอธิบายโดยย่อของขั้นตอนต่างๆ เพื่อให้คุณหาบทเรียนที่เหมาะสมเพื่อเรียนรู้เพิ่มเติมได้

# Added by doQumentation — required packages for this notebook
!pip install -q numpy pandas qiskit

# Import some qiskit packages required for setting up our quantum circuits.
from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit
from qiskit.circuit.library import unitary_overlap

# Import StatevectorSampler as our sampler.
from qiskit.primitives import StatevectorSampler

# Step 1: Map classical inputs to a quantum problem:

# Start by getting some appropriate data. The data imported below consist of 128 rows or data points.
# Each row has 14 columns that correspond to data features, and a 15th column with a label (+/-1).
!wget https://raw.githubusercontent.com/qiskit-community/prototype-quantum-kernel-training/main/data/dataset_graph7.csv

# Import some required packages, and write a function to pull some training data out of the csv file you got above.
import pandas as pd
import numpy as np

def get_training_data():
    """Read the training data."""
    df = pd.read_csv("dataset_graph7.csv", sep=",", header=None)
    training_data = df.values[:20, :]
    ind = np.argsort(training_data[:, -1])
    X_train = training_data[ind][:, :-1]

    return X_train

# Prepare training data
X_train = get_training_data()

# Empty kernel matrix
num_samples = np.shape(X_train)[0]

# Prepare feature map for computing overlap between two data points.
# This could be pre-built feature maps like ZZFeatureMap, or a custom quantum circuit, as shown here.
num_features = np.shape(X_train)[1]
num_qubits = int(num_features / 2)
entangler_map = [[0, 2], [3, 4], [2, 5], [1, 4], [2, 3], [4, 6]]
fm = QuantumCircuit(num_qubits)
training_param = Parameter("θ")
feature_params = ParameterVector("x", num_qubits * 2)
fm.ry(training_param, fm.qubits)
for cz in entangler_map:
    fm.cz(cz[0], cz[1])
for i in range(num_qubits):
    fm.rz(-2 * feature_params[2 * i + 1], i)
    fm.rx(-2 * feature_params[2 * i], i)

# Pick two data points, here 14 and 19, and assign the features to the circuits as parameters.
x1 = 14
x2 = 19
unitary1 = fm.assign_parameters(list(X_train[x1]) + [np.pi / 2])
unitary2 = fm.assign_parameters(list(X_train[x2]) + [np.pi / 2])

# Create the overlap circuit
overlap_circ = unitary_overlap(unitary1, unitary2)
overlap_circ.measure_all()
overlap_circ.draw("mpl", scale=0.6, style="iqp")

# Step 2: Optimize problem for quantum execution

# Use Qiskit Runtime service to get the least busy backend for running on real quantum computers.
# from qiskit_ibm_runtime import QiskitRuntimeService

# service = QiskitRuntimeService(channel="ibm_quantum")
# backend = service.least_busy(
#    operational=True, simulator=False, min_num_qubits=overlap_circ.num_qubits
# )

# Transpile the circuits optimally for the chosen backend using a pass manager.
# from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
# pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
# overlap_ibm = pm.run(overlap_circ)

# Step 3: Execute using Qiskit Runtime Primitives

# Specify the number of shots to use.
num_shots = 10_000

## Evaluate the problem using statevector-based primitives from Qiskit
sampler = StatevectorSampler()
counts = (
    sampler.run([overlap_circ], shots=num_shots).result()[0].data.meas.get_int_counts()
)

# Step 4: Analyze and post-processing

# Find the probability of 0.
counts.get(0, 0.0) / num_shots

--2025-05-09 10:04:28--  https://raw.githubusercontent.com/qiskit-community/prototype-quantum-kernel-training/main/data/dataset_graph7.csv
Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.109.133, 185.199.108.133, ...
Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 49405 (48K) [text/plain]
Saving to: ‘dataset_graph7.csv.2’

dataset_graph7.csv. 100%[===================>]  48.25K  --.-KB/s    in 0.03s   

2025-05-09 10:04:29 (1.37 MB/s) - ‘dataset_graph7.csv.2’ saved [49405/49405]

0.8199

แม้ว่าคุณไม่จำเป็นต้องเข้าใจทุกขั้นตอนข้างต้น แต่เราควรพยายามเข้าใจ output เพื่อรู้ว่าทำไมเราถึงทำสิ่งนี้ กระบวนการ machine learning หลายอย่างใช้ inner products เป็นส่วนหนึ่งของ binary classification (รวมถึงสิ่งอื่นๆ) quantum mechanics มีการเชื่อมต่อที่ชัดเจนกับเรื่องนี้ เนื่องจาก probability ของการวัด states ต่างๆ $|\phi_i\rangle$ ถูกให้โดย inner product กับ initial state $|\psi\rangle$ ผ่าน inner product: $P_i = |\langle\phi_i|\psi\rangle|^2$ ดังนั้นสิ่งที่เราทำข้างต้นคือสร้าง quantum circuit ที่มี features ของจุดข้อมูลสองจุดของเรา และ map พวกมันไปยังพื้นที่ของ quantum vector จากนั้นประมาณ inner product ในพื้นที่นั้นผ่านการวัด นี่คือตัวอย่างของ quantum kernel estimation โปรดทราบว่าเราดำเนินการกระบวนการนี้สำหรับจุดข้อมูลสองจุดเท่านั้น (ที่ 14 และ 19) ถ้าเราทำเช่นนี้สำหรับคู่ที่เป็นไปได้ทั้งหมด เราสามารถนำ output (ในกรณีนี้คือตัวเลข 0.821...) มาเติมเมทริกซ์ของผลลัพธ์ที่อธิบาย overlap ระหว่างจุดทั้งหมดใน training data set นี่คือ "kernel matrix"

ตรวจสอบความเข้าใจ

อ่านคำถามด้านล่าง คิดคำตอบของคุณ จากนั้นคลิกสามเหลี่ยมเพื่อดูคำเฉลย

ในกระบวนการข้างต้น เราคำนวณ kernel matrix entry สำหรับจุดข้อมูลที่ 14 และ 19 ค่าที่เราควรได้รับถ้าเราใช้จุดข้อมูลเดียวกันสองครั้งคืออะไร (เช่น ที่ 14 และ 14 อีกครั้ง) หรือพูดอีกนัยหนึ่ง entries แนวทแยงใน kernel matrix ควรเป็นอะไร? ตอบคำถามนี้ในกรณีที่ไม่มี noise แต่โปรดทราบว่าค่าเบี่ยงเบนจากคำตอบของคุณเป็นไปได้ในกรณีที่มี noise

คำตอบ:

แนวทแยงควรเป็น 1.0 กระบวนการนี้ควรคำนวณ normalized inner product ของ vector กับตัวมันเอง ซึ่งต้องเป็นหนึ่งเสมอ