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

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

Оно работает! Вроде, как бы, что-то вроде….

Открытый вопрос от 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 выстрелов разброс в подсчетах составляет всего 1 200–1 400, хотя обычно я ожидаю разброс 4 000–4 500.

Если кому-то нужно напомнить, методы ядра сравнивают квантовые состояния. Если два состояния идентичны, они измеряют 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.