Квантова класификация на амплитудите

Квантова класификация на амплитудите

Работи! Нещо като….

Отвореният въпрос от 784-Dimensional Quantum MNIST е, работи ли «квантовата класификация с амплитудно кодиране?» Алгоритъмът работеше толкова бавно, сравнявайки (симулирани) 10-кубитови квантови системи, че резултатите бяха неубедителни. Нямах търпението да направя повече от 10 снимки за сравнение и, оказа се, вероятно ще са необходими милиони снимки.

Първо, направих грешката на новобранеца да изтегля 8-измерен набор от данни, който никога преди не бях използвал. Чувствайте се свободни да ме ругаете в коментарите и в социалните медии за това. Сериозно, заслужавам го.

Целта на това упражнение беше да се картографират 8 характеристики на данни към 3 кубита, като се приеме, че сравненията с 3 кубита ще се изпълняват значително по-бързо от сравненията с 10 кубита. Добрата новина е: това е вярно. Лошата новина е: резултатите бяха безполезни. Данните ли бяха? Все още не знам, но със сигурност трябва да се предположи. И е жалко, честно казано, защото тази статия би била за използването на квантова класификация с амплитудно кодиране за предсказване на диабет.

Както и да е, върнах се в самото начало, когато започнах да сравнявам квантовите състояния. Създадох произволен набор от данни с по-ниски числа, класифицирани като 0, и по-високи числа, класифицирани като 1. Колкото и да е непрактично в реалния свят, смисълът отново е да се определи дали сравнението работи или не, след като тези числа се преобразуват в амплитуди и се пакетират в много малко кубити. Също така създадох друг случаен набор от данни, който умишлено беше по-близък до класификация 1. Щеше ли да се класифицира правилно като 1 или щеше да докаже, че класифицирането на амплитудно кодирани данни е невъзможно?

0
{'1': 1345, '0': 8655}
{'1': 10, '0': 9990}
1
{'1': 1289, '0': 8711}
{'1': 5, '0': 9995}
2
{'1': 1402, '0': 8598}
{'1': 6, '0': 9994}
3
{'1': 1296, '0': 8704}
{'1': 12, '0': 9988}
4
{'1': 1202, '0': 8798}
{'1': 10, '0': 9990}
5
{'1': 1319, '0': 8681}
{'1': 13, '0': 9987}
6
{'1': 1358, '0': 8642}
{'1': 15, '0': 9985}
7
{'1': 1322, '0': 8678}
{'1': 14, '0': 9986}
8
{'1': 1291, '0': 8709}
{'1': 20, '0': 9980}
9
{'1': 1261, '0': 8739}
{'1': 15, '0': 9985}

За всяко число 0–9 по-горе има 2 сравнения. Това е неефективно, да, но, отново, въпросът е лесно да се види дали това работи или не. Най-добрият резултат за итерация е сравнението с класификация 0, а най-ниските резултати за итерация е сравнението с класификация 1. Добрата новина е: проработи! Лошата новина е: има много малко разделение в резултатите, така че е трудно да се види, че работи с данни от реалния свят. Пускайки 10 000 изстрела, има само 1200–1400 спред в броя, въпреки че обикновено очаквам 4000–4500 спред.

Ако някой има нужда от опресняване, методите на ядрото сравняват квантовите състояния. Ако две състояния са идентични, те измерват 0 със 100% вероятност. Ако състоянията са полярни противоположности, те измерват 0 с 50% вероятност. Колкото по-близо са две състояния, толкова по-често измерват 0. Следователно две много близки състояния могат да измерват 0 с 90–95% вероятност, а две много отдалечени състояния може да измерват 0 с 55–60% вероятност. Ето защо квантовата класификация работи: кодирайте вашите данни като квантови състояния и кои състояния вашите тестови данни са най-близки, е вероятната класификация. Навлизам в подробности в моята безплатна електронна книга, „Dungeons & Qubits: An Adventurer’s Tale Beyond the Quantum Computing Tutorials.“

Резултатите по-горе показват, че пристрастните данни от теста, както беше предназначено, измерваха 0 по-често в сравнение с класификация 1 (по-ниският резултат), отколкото в сравнение с класификация 0 (по-високият резултат). Следователно данните от теста вероятно са класификация 1. По принцип МОЖЕТЕ да класифицирате амплитудно кодирани данни.

0
{'1': 1401, '0': 8599}
{'1': 17, '0': 9983}
1
{'0': 8562, '1': 1438}
{'1': 19, '0': 9981}
2
{'1': 1357, '0': 8643}
{'1': 16, '0': 9984}
3
{'1': 1421, '0': 8579}
{'1': 13, '0': 9987}
4
{'1': 1368, '0': 8632}
{'1': 11, '0': 9989}
5
{'1': 1364, '0': 8636}
{'1': 15, '0': 9985}
6
{'1': 1448, '0': 8552}
{'1': 17, '0': 9983}
7
{'0': 8631, '1': 1369}
{'1': 16, '0': 9984}
8
{'1': 1393, '0': 8607}
{'1': 19, '0': 9981}
9
{'1': 1334, '0': 8666}
{'1': 19, '0': 9981}

Разширяването от 3-кубитови състояния до 4-кубитови състояния вече въвежда леко забавяне във времето на изпълнение. Все още не е лошо, но е предвестник на предстоящи забавяния. Използвайки същия алгоритъм, което е важно, можем да видим, че той все още работи. Класификация 1 все още е вероятната класификация за необективните данни от теста.

0
{'1': 396, '0': 9604}
{'1': 11, '0': 9989}
1
{'1': 413, '0': 9587}
{'1': 9, '0': 9991}
2
{'1': 393, '0': 9607}
{'1': 14, '0': 9986}
3
{'1': 406, '0': 9594}
{'1': 15, '0': 9985}
4
{'1': 410, '0': 9590}
{'1': 22, '0': 9978}
5
{'1': 450, '0': 9550}
{'1': 19, '0': 9981}
6
{'1': 444, '0': 9556}
{'1': 17, '0': 9983}
7
{'1': 393, '0': 9607}
{'1': 13, '0': 9987}
8
{'1': 417, '0': 9583}
{'1': 17, '0': 9983}
9
{'1': 392, '0': 9608}
{'1': 9, '0': 9991}

Разширяването до 5-кубитови състояния също така удължава паузите между изпълнението на задачи. Все още работи при 10 000 изстрела, но можем да видим, че разделянето е само няколкостотин. Тук работим с много малки амплитуди; равномерно разпределение (равни вероятности) на 32 амплитуди е само 0,17677669529663688110021109052621, така че можете да видите колко трудно може да бъде откриването на леки отклонения.

И така, последният тест, който ще направя за тази статия, е какво ще направя, ако увелича значително броя на ударите? Това ще покаже ли повече разделяне с по-висок брой кубити?

0
{'1': 3912, '0': 96088}
{'1': 133, '0': 99867}
1
{'1': 4208, '0': 95792}
{'1': 125, '0': 99875}
2
{'1': 4177, '0': 95823}
{'1': 122, '0': 99878}
3
{'1': 4026, '0': 95974}
{'1': 169, '0': 99831}
4
{'1': 3976, '0': 96024}
{'1': 134, '0': 99866}
5
{'1': 3966, '0': 96034}
{'1': 119, '0': 99881}
6
{'1': 3976, '0': 96024}
{'1': 146, '0': 99854}
7
{'1': 4200, '0': 95800}
{'1': 135, '0': 99865}
8
{'1': 3888, '0': 96112}
{'1': 106, '0': 99894}
9
{'1': 3842, '0': 96158}
{'1': 126, '0': 99874}

Нещо като? Увеличих броя на изстрелите от 10 000 на 100 000 и разделението се промени от няколкостотин на няколко хиляди. Съотношението остана същото, но десетичната запетая се премести с едно място надясно. Така че можете да направите аргумента, че по-високият брой удари позволява повече разделяне на резултатите.

Заключение

Работи квантова класификация на амплитудно кодирани данни. С по-малки квантови състояния можем да видим това. Проблемът е, че с нарастването на броя на кубитите амплитудите стават толкова малки, че стават все по-трудни и по-трудни за разграничаване. Можем да увеличим разделянето в резултатите чрез увеличаване на броя на изстрелите, но всеки допълнителен кюбит значително забавя времето на изпълнение. С 10-кубитови състояния едва имах търпението да направя 10 изстрела.

Всичко това обаче се отнася до симулация на квантови изчисления. Нямам достатъчно налични кубити, за да стартирам това на квантов процесор, но дори и да имах, резултатът от амплитудно кодиране и множество гейтове на Фредкин на NISQ устройство ще бъде чист шум. Сравних две 2-кубитови състояния на 5-кубитов бекенд на IBM Quantum и вече има значителен шум в този мащаб.

Но какво ще се случи, когато най-накрая получим логически кубити (устойчиви на грешки, коригирани грешки, прилична кохерентност)? Експериментът на Google „Quantum Supremacy“ отне само 200 секунди с 53 кубита и аз чаках много повече от това, за да симулирам 100 000 изстрела с 11 кубита. Така че определено трябва да видим „квантово предимство“ по отношение на времето за изпълнение, но ще можем ли да различим резултатите с данни от реалния свят? Само времето ще покаже….

Искате ли да играете с кода? Не е оптимизиран, но е в GitHub.