Как указать значение квантовых чисел для canon

Учебник. Реализация квантового генератора случайных чисел на языке Q#

В примерах в этом разделе используется microsoft Quantum Development Kit (классический QDK) и они еще не совместимы с предварительной версией Azure Quantum Development Kit (современный QDK). Дополнительные сведения о современном QDK см. в GitHub Wiki QSharp.

Здесь вы узнаете, как создать простую квантовую программу на языке Q#, которая использует природу квантовой механики для получения случайного числа.

Из этого учебника вы узнаете, как выполнять следующие задачи:

• создать проект Q#;
• подготовить среду разработки для написания квантовых программ на Q#;
• использовать структуру программ на Q#;
• Работа с кубитами и суперпозицией для создания квантового генератора случайных чисел.

Если вы хотите ускорить путь квантовых вычислений, проверка copilot в Azure Quantum, уникальную функцию веб-сайта Azure Quantum. С помощью Copilot вы можете запускать программы Q# , создавать новый Q# код на основе запросов и задавать любые вопросы о квантовых вычислениях.

Предварительные требования

• Чтобы запустить пример кода в Copilot в Azure Quantum, выполните следующие действия:
  • Учетная запись электронной почты Майкрософт (MSA).
  • Quantum Development KitУстановите (QDK) с использованием предпочитаемого языка и среды разработки. В этом учебнике представлено решение в трех разных форматах:
    • Q# Автономный
    • Q# и Python
    • Q# и C#

    Создание проекта Q#

    Первое, что нужно сделать, — это создать проект Q#. В этом учебнике мы используем среду на основе приложений Q# с VS Code, но вы можете использовать другую интегрированную среду разработки, которую предпочитаете.

    Создайте новый проект в Visual Studio Code, выполнив следующие действия.

    1. Щелкните View ->Command Palette (Представление — Палитра команд) и выберите Q#: Create New Project (Создать проект).
    2. Выберите Standalone console application (Автономное консольное приложение).
    3. Выберите расположение для сохранения проекта, присвойте ему имя Qrngи щелкните Create Project (Создать проект).
    4. После успешного создания проекта щелкните Open new project. (Открыть новый проект. ) в правом нижнем углу.

    Это приводит к созданию двух файлов: файла проекта Qrng.csproj и шаблона приложения Q#Program.qs, которые будут использоваться для создания приложения.

    Написание операции Q#

    Замените содержимое файла Program.qs следующим кодом:

    namespace Qrng < open Microsoft.Quantum.Convert; open Microsoft.Quantum.Math; open Microsoft.Quantum.Measurement; open Microsoft.Quantum.Canon; open Microsoft.Quantum.Intrinsic; operation SampleQuantumRandomNumberGenerator() : Result < // Allocate a qubit use q = Qubit(); // Put the qubit to superposition // It now has a 50% chance of being measured 0 or 1 H(q); // Measure the qubit value and reset the qubit return MResetZ(q); >> 

    Теперь давайте изучим этот новый код.

    • Прежде всего выполните open для нужных пространств имен из библиотек Q#, чтобы получить возможность использовать необходимые функции и операции.
    • Вы определяете операцию SampleQuantumRandomNumberGenerator , которая не принимает никаких входных данных и формирует значение типа Result . Тип Result представляет результат измерения и может иметь два возможных значения: Zero или One .
    • Выделите один кубит с помощью ключевого слова use .
    • Примените операцию H (операцию Адамара), чтобы перевести кубит в равновесную суперпозицию.
    • MResetZ Используйте операцию для измерения кубита, верните измеряемое значение ( Zero или One ), а затем сбросьте кубит, чтобы его можно было использовать снова.

    Кубит — это единица квантовой информации, которая может находиться в суперпозиции. (Дополнительные сведения о кубитах и суперпозиции см. в разделе Общие сведения о квантовых вычислениях.) При измерении кубит может находиться только в состоянии 0 или в состоянии 1 . Однако до измерения состояние кубита представляет вероятность получить значение 0 или 1 при измерении. В нашем примере перед измерением кубит находится в равновесном состоянии суперпозиции, то есть вероятность получить 0 составляет 50 %, и вероятность получить 1 — также 50 %. Эту вероятность можно использовать для создания случайных чисел.

    Определяемая пользователем операция SampleQuantumRandomNumberGenerator вводит тип данных Qubit , который является собственным для Q#. Qubit можно выделить только с помощью инструкции use . Только что выделенный кубит всегда находится в состоянии Zero .

    Если мы переводим кубит в состояние суперпозиции с помощью операции H и измеряем его с помощью операции MResetZ , при каждом вызове кода возвращаются разные результаты.

    Визуализация кода в формате сферы Блоха

    В сфере Блоха северный полюс соответствует классическому значению 0, а южный — классическому значению 1. Любое состояние суперпозиции обозначается точкой на этой сфере (или стрелкой на схеме). Чем ближе конец этой стрелки к одному из полюсов, тем выше вероятность схлопывания этого кубита при измерении в то классическое состояние, которое соответствует этому полюсу. В примере ниже красная стрелка обозначает состояние кубита с более высокой вероятностью получить значение 0 при измерении кубита.

    Вы можете использовать это представление для визуализации работы нашего кода.

    • Для начала инициализируйте кубит в состоянии 0 и примените H , чтобы создать состояние суперпозиции с равной вероятностью получить значения 0 и 1.

    

    • Затем измерьте состояние кубита и сохраните выходное значение:

    

    Поскольку результат измерения является случайным и вероятности получения 0 и 1 одинаковы, вы получили совершенно случайный бит. Вызывая эту операцию несколько раз, вы можете создавать большие целые числа. Например, три вызова этой операции предоставят вам три случайных бита, из которых можно собрать трехбитовое число (то есть случайное число в диапазоне от 0 до 7).

    Создание генератора комплексных случайных чисел

    Теперь, когда есть операция Q#, создающая случайные биты, можно объединить несколько случайных битов, чтобы создать квантовый генератор комплексных случайных чисел. Эту программу можно выполнять как автономное приложение Q# или через основное приложение на Python или .NET, которое вызывает код Q#.

    Определение логики генератора случайных чисел

    Для начала опишите требуемую логику генератора случайных чисел на основе уже имеющегося генератора случайных битов:

    1. Определите для параметра max значение максимального числа, которое требуется создать.
    2. Определите количество случайных битов, которые требуется создать. Для этого вычислите, сколько битов (numBits) вам потребуется для выражения всех целых чисел вплоть до требуемого максимального значения.
    3. Создайте строку случайных битов длиной numBits.
    4. Если битовая строка содержит число больше значения max, вернитесь к шагу 3.
    5. В противном случае процесс завершается. Возврат созданного числа в виде целого числа.

    Определение операции

    Затем определите операцию SampleRandomNumberInRange , которая использует цикл for для многократного вызова операции SampleQuantumRandomNumberGenerator и создания строки битов.

    Внесите в файл Program.qs изменения, выполняющие новую операцию:

    namespace Qrng < open Microsoft.Quantum.Canon; open Microsoft.Quantum.Intrinsic; open Microsoft.Quantum.Measurement; open Microsoft.Quantum.Math; open Microsoft.Quantum.Convert; operation SampleQuantumRandomNumberGenerator() : Result < // Allocate a qubit use q = Qubit(); // Put the qubit to superposition // It now has a 50% chance of being measured 0 or 1 H(q); // Measure the qubit value return MResetZ(q); >operation SampleRandomNumberInRange(max : Int) : Int < mutable output = 0; repeat < mutable bits = []; for idxBit in 1..BitSizeI(max) < set bits += [SampleQuantumRandomNumberGenerator()]; >set output = ResultArrayAsInt(bits); > until (output > 

    Теперь давайте внимательнее рассмотрим эту новую операцию.

    • Чтобы вычислить количество битов, необходимое для выражения целых чисел вплоть до значения max , можно воспользоваться функцией BitSizeI .
    • Операция SampleRandomNumberInRange использует цикл repeat для создания случайных чисел до тех пор, пока не будет получено значение, которое меньше или равно max .
    • Цикл for в цикле repeat работает так же, как цикл for на других языках программирования.
    • В этом примере output и bits являются изменяемыми переменными. Изменяемая переменная может изменяться во время вычисления. Для изменения значения изменяемой переменной используется директива set .
    • Функция ResultArrayAsInt преобразует строку битов в положительное целое число.

    Теперь программа Qrng может создавать случайные числа.

    Запуск программы генератора случайных чисел

    Используя окончательную версию кода Q#,

    namespace Qrng < open Microsoft.Quantum.Canon; open Microsoft.Quantum.Intrinsic; open Microsoft.Quantum.Measurement; open Microsoft.Quantum.Math; open Microsoft.Quantum.Convert; operation SampleQuantumRandomNumberGenerator() : Result < // Allocate a qubit use q = Qubit(); // Put the qubit to superposition // It now has a 50% chance of being measured 0 or 1 H(q); // Measure the qubit value return MResetZ(q); >operation SampleRandomNumberInRange(max : Int) : Int < mutable output = 0; repeat < mutable bits = []; for idxBit in 1..BitSizeI(max) < set bits += [SampleQuantumRandomNumberGenerator()]; >set output = ResultArrayAsInt(bits); > until (output > 

    Выберите вкладку для предпочитаемого языка и среды и следуйте инструкциям по запуску или вызову Q# программы.

    • Copilot в Azure Quantum
    • Автономное приложение Q# в Visual Studio или Visual Studio Code
    • Python с Visual Studio Code или командной строкой
    • C# с Visual Studio Code или Visual Studio

    Вы можете бесплатно протестировать Q# код с помощью Copilot в Azure Quantum. Вам потребуется только учетная запись электронной почты Майкрософт (MSA). Дополнительные сведения о Copilot в Azure Quantum см. в статье Изучение Azure Quantum.

    Автономное приложение Q# требует указать значение EntryPoint , чтобы компилятор Q# знал, где нужно запускать программу. Чтобы создать полное приложение Q#, добавьте в программу Q# (Program.qs) следующую точку входа:

    namespace Qrng < open Microsoft.Quantum.Canon; open Microsoft.Quantum.Intrinsic; open Microsoft.Quantum.Measurement; open Microsoft.Quantum.Math; open Microsoft.Quantum.Convert; operation SampleQuantumRandomNumberGenerator() : Result < // Allocate a qubit. use q = Qubit(); // Put the qubit to superposition. H(q); // It now has a 50% chance of being measured 0 or 1. // Measure the qubit value. return MResetZ(q); >operation SampleRandomNumberInRange(max : Int) : Int < mutable output = 0; repeat < mutable bits = []; for idxBit in 1..BitSizeI(max) < set bits += [SampleQuantumRandomNumberGenerator()]; >set output = ResultArrayAsInt(bits); > until (output @EntryPoint() operation SampleRandomNumber() : Int < let max = 50; Message($"Sampling a random number between 0 and : "); return SampleRandomNumberInRange(max); > > 

    Программа запускает операцию или функцию, помеченную атрибутом @EntryPoint() , в симуляторе полного состояния по умолчанию.

    Скопируйте и вставьте полный пример кода в Copilot в Azure Quantum, выберите количество снимков для выполнения и нажмите кнопку Выполнить. Результаты отображаются в гистограмме и в полях Результаты .

    Файл проекта не требуется для выполнения Q# кода в Copilot в Azure Quantum. Аналогичным образом установка QDK не требуется, так как в copilot уже выполняется последняя версия QDK.

    Автономное приложение Q# требует указать значение EntryPoint , чтобы компилятор Q# знал, где нужно запускать программу. Чтобы создать полное приложение Q#, добавьте в программу Q# (Program.qs) следующую точку входа:

    namespace Qrng < open Microsoft.Quantum.Canon; open Microsoft.Quantum.Intrinsic; open Microsoft.Quantum.Measurement; open Microsoft.Quantum.Math; open Microsoft.Quantum.Convert; operation SampleQuantumRandomNumberGenerator() : Result < // Allocate a qubit. use q = Qubit(); // Put the qubit to superposition. H(q); // It now has a 50% chance of being measured 0 or 1. // Measure the qubit value. return MResetZ(q); >operation SampleRandomNumberInRange(max : Int) : Int < mutable output = 0; repeat < mutable bits = []; for idxBit in 1..BitSizeI(max) < set bits += [SampleQuantumRandomNumberGenerator()]; >set output = ResultArrayAsInt(bits); > until (output @EntryPoint() operation SampleRandomNumber() : Int < let max = 50; Message($"Sampling a random number between 0 and : "); return SampleRandomNumberInRange(max); > > 

    Программа запускает операцию или функцию, помеченную атрибутом @EntryPoint() в симуляторе по умолчанию или другом указанном azure Quantum target.

    В Visual Studio просто нажмите сочетание клавиш CTRL+F5, чтобы выполнить скрипт.

    При первом выполнении в VS Code нужно скомпилировать файл Program.qs, введя следующую команду в окне терминала:

    dotnet build 

    Для последующих выполнений файл не нужно создавать повторно. Для выполнения введите следующую команду и нажмите клавишу ВВОД:

    dotnet run --no-build 

    При использовании Python для запуска программы Q# не обязательно добавлять EntryPoint в файл Q#. Вместо этого вы создадите основное приложение на языке Python, которое импортирует и выполняет операцию SampleQuantumRandomNumberGenerator .

    Сохраните следующий код как host.py :

    import qsharp # Import the quantum operation from the namespace defined in the program.qs file from Qrng import SampleQuantumRandomNumberGenerator # Set the maximum range max = 50 # Variable to store the output output = max + 1 while output > max: # Initialize a list to store the bits that will define the random integer bit_string = [] # Call the quantum operation as many times as there are bits # needed to define the maximum of the range. For example, if max=7, you need three bits # to generate all the numbers from 0 to 7. for i in range(0, max.bit_length()): # Call the quantum operation and store the random bit in the list bit_string.append(SampleQuantumRandomNumberGenerator.simulate()) # Transform bit string to integer output = int("".join(str(x) for x in bit_string), 2) # Print the random number print("The random number generated is " + str(output)) 

    Теперь вы сможете запустить основную программу Python из командной строки следующим образом:

    $ python host.py Preparing Q# environment. ..The random number generated is 42 

    При использовании C# или F# для запуска программы Q# не обязательно добавлять EntryPoint в файл Q#. Вместо этого создайте управляющую программу на языке C#, которая ссылается на файл Q# и вызывает операцию SampleQuantumRandomNumberGenerator .

    В проекте внесите изменения в файл Program.qs, добавив следующий код C#:

    using System; using Microsoft.Quantum.Simulation.Core; using Microsoft.Quantum.Simulation.Simulators; using System.Linq; namespace Qrng < class Driver < static void Main(string[] args) < using (var sim = new QuantumSimulator()) < // First we initialize all the variables: var bitString = "0"; // To save the bit string int max = 50; // The maximum of the range int size = Convert.ToInt32(Math.Floor(Math.Log(max, 2.0) + 1)); // To calculate the amount of needed bits int output = max + 1; // Int to store the output while (output >max) // Loop to generate the number < bitString = "0"; // Restart the bit string if fails bitString = String.Join("", Enumerable.Range(0, size).Select(idx =>SampleQuantumRandomNumberGenerator.Run(sim).Result == Result.One ? "1" : "0" )); // Generate and concatenate the bits using the Q# operation // Convert the bit string to an integer output = Convert.ToInt32(bitString, 2); > // Print the result Console.WriteLine($"The random number generated is ."); > > > > 

    Теперь вы сможете запустить основное приложение на C# из командной строки следующим образом (или нажать сочетание клавиш Ctrl+F5 в Visual Studio):

    $ dotnet run The random number generated is 42 

    Этот фрагмент кода в настоящее время не выполняется на доступном оборудовании targetsAzure Quantum, так как вызываемому объекту требуется ResultArrayAsInt QPU с полным профилем вычислений.

    Дальнейшие действия

    Ознакомьтесь с другими учебниками по Q#:

    • Исследование запутанности на языке Q# показывает, как написать программу Q#, которая изменяет состояние кубитов и измеряет их для демонстрации явлений суперпозиции и запутанности.
    • Руководство по реализация поиска по алгоритму Гровера на Q# демонстрирует создание программы Q#, которая алгоритм поиска Гровера для решения проблемы раскраски графа.
    • Руководство Создание и имитация программ уровня кубита на Q# демонстрирует создание программы Q#, которая напрямую обращается к конкретным кубитам.

    Изучаем Q#. Орёл или решка?

    

    Как и бит, кубит допускает два собственных состояния, обозначаемых |0> и |1> (обозначения Дирака), но при этом может находиться и в их суперпозиции.

    В общем случае его волновая функция имеет вид A|0>+B|1>, где A и B называются амплитудами вероятностей и являются комплексными числами, удовлетворяющими условию |A|^2+|B|^2=1 (но это не обязательно соблюдать при записи — всегда подразумевается, что происходит нормирование величин).

    При измерении состояния кубита можно получить лишь одно из его собственных состояний.

    Вероятности получить каждое из них равны соответственно |A|^2 и |B|^2.

    Как правило, при измерении состояние кубита необратимо разрушается, чего не происходит при измерении классического бита.

    В квантовых вычислениях, мы имеем факт, что применение трансформации Адамара H к кубиту в состоянии |0> даёт нам его в равновероятном состоянии для исходов |0> и |1>, то есть в состоянии |0>+|1>

    Но как нам задать нужное состояние кубита, то есть с заранее заданными значениями A и B ?

    Вернее, как задать нужное состояние кубита, используя только минимальный набор базовых операций? Ведь любой QDK должен включать в себя методы инициализации кубита (и желательно в требуемом состоянии).

    Ну а мы ограничимся в данном примере операциями H и Controlled X.

    Как будем решать проблему?

    Важнейшее свойство квантовых вычислений — это возможность переводить массивы кубитов в запутанное состояние.

    Предположим у нас есть регистр (массив) кубитов, находящийся в состоянии SUM |k> где k=0..N-1 — то есть при попытке измерения мы получим значение из диапазона 0..N-1 с одинаковой вероятностью.

    Если мы разделим множество 0..N-1 на два множества A и B то можем сделать функцию f(k)= . Очеводно, что для произвольно выбранного значения k выполнено P(f(k)==0)=|A|/N и P(f(k)==1)=|B|/N и при этом |A|+|B|=N.

    А как проще всего разделить 0..N-1 на два подмножества — конечно пороговой функцией fw(k)= или, в другой записи fw(k)=SIGN(w-k-1), где SIGN(x)=

    При этом p=P(0)=w/N и q=P(1)=(N-w)/N

    Рассмотрим классическую схему построения трансформации, для булевой функции fw

    Uw(x,y)=(x,y xor fw(x))

    

    Имеем, что после применения трансформации Uw к регистру в состоянии SUM |k>|0> он перейдёт в состояние SUM |k>|fw(k)>, а при измерении выходного кубита, будет происходить его коллапсирование и измерение вернёт значение |0> с вероятностью p=w/N и |1> с вероятностью q=1-p=(N-w)/N. То есть, если мы в дальнейшем перестанем обращать внимание на значения входных кубитов, то для нас выходной кубит будет просто находиться в состоянии SQRT(p)|0>+SQRT(q)|1>, то есть мы решили задачу — как задать параметры у возможных состояний кубита (мы задали состояние кубита).

    Как проверить, что рассуждения корректны?

    Ответ — практика. То есть для заданных значений p и q многократно повторим эксперимент задание начального состояния кубита и измерение его значения (коллапсирование). Статистика полученных результатов |0> и |1> должна совпасть с заданными параметрами p и q.

    А вот и программка и её результат

    namespace qrnd < open Microsoft.Quantum.Canon; open Microsoft.Quantum.Intrinsic; open Microsoft.Quantum.Arrays; open Microsoft.Quantum.Convert; open Microsoft.Quantum.Math; open Microsoft.Quantum.Logical; open Microsoft.Quantum.Diagnostics; open Microsoft.Quantum.Bitwise; /// # Описание /// измерение значений (коллапсирование) кубитов в массиве (который рассматриваем как один регистр) /// и возврат числа (равного полученной двоичной последовательности) operation Measure(qubits: Qubit[]) : Int < let results = ForEach(M, qubits); let i = ResultArrayAsInt(results); return i; >/// # Описание /// вычисления знака переноса при арифметической операции сложения /// то есть трансформация вида |k>|0> -> |k>|sign(k+value)> operation Sign(target: Qubit[], sign: Qubit, value: Int) : Unit < let k = Length(target); let bools = IntAsBoolArray(2^k-value, k); use (qubits) = (Qubit[2]) < for idx in 0..k-1 < let carry = qubits[idx%2]; let next = qubits[1-(idx%2)]; // вычисляем следующее значение флага переноса разряда if(bools[idx]) < // next = carry*target[idx]^carry^target[idx] Controlled X([carry, target[idx]], next); Controlled X([carry], next); Controlled X([target[idx]], next); >else < // next = carry*target[idx] = carry&target[idx] Controlled X([carry, target[idx]], next); >Reset(carry); > Controlled X([qubits[k%2]], sign); ResetAll(qubits); > > @EntryPoint() operation Main(n: Int, w: Int, tests: Int) : Unit < Message("Hello quantum world!"); let N=2^n; let p=100*w/N; let q=100*(N-w)/N; Message($"n=w= N= p=
    % q=% tests="); mutable counters = [0, size=2]; use (x,y)=(Qubit[n],Qubit()) < for _ in 1..tests < ApplyToEach(H,x); Sign(x,y,w); let res = Measure([y]); set counters w/= res > let f = [w,N-w]; mutable total = 0; for element in f < set total+=element; >for idx in 0..1 < let expect = tests*f[idx]/N; let fact = counters[idx]; Message($": . expect= . fact="); > > > 

    PS C:\Projects\qrnd> dotnet run -n 4 -w 5 --tests 1000 Hello quantum world! n=4 w=5 N=16 p=31% q=68% tests=1000 0: . expect=312 . fact=289 1: . expect=687 . fact=711 PS C:\Projects\qrnd> dotnet run -n 4 -w 5 --tests 1000 Hello quantum world! n=4 w=5 N=16 p=31% q=68% tests=1000 0: . expect=312 . fact=275 1: . expect=687 . fact=725 PS C:\Projects\qrnd> dotnet run -n 4 -w 5 --tests 1000 Hello quantum world! n=4 w=5 N=16 p=31% q=68% tests=1000 0: . expect=312 . fact=292 1: . expect=687 . fact=708 PS C:\Projects\qrnd> dotnet run -n 4 -w 5 --tests 1000 Hello quantum world! n=4 w=5 N=16 p=31% q=68% tests=1000 0: . expect=312 . fact=324 1: . expect=687 . fact=676 

    И задачка со звёздочкой

    А давайте рассмотрим трансформацию U(w,x,y)=(w,x,y xor SIGN(w-x-1)) где параметр w так же перебирается с помощью квантовых вычислений, то есть так же описывается суммой возможных состояний (с вероятностями).

    Но это, как говорится, уже другая история . тут и алгоритм Гровера становится более интересным .

    Ссылки

    • https://github.com/dprotopopov/qrnd
    • https://learn.microsoft.com/ru-ru/azure/quantum/tutorial-qdk-grovers-search?tabs=tabid-visualstudio
    • https://learn.microsoft.com/ru-ru/azure/quantum/user-guide/host-programs?tabs=tabid-copilot
    • https://learn.microsoft.com/ru-ru/training/modules/qsharp-create-first-quantum-development-kit/2-install-quantum-development-kit-code

    Ранее

    • Изучаем Q#. Обучаем перцептрон
    • Изучаем Q#. Статистическое сравнение двух последовательностей чисел
    • Изучаем Q#. Алгоритм Гровера. Не будите спящего Цезаря
    • Изучаем Q#. Делаем реализацию биноминального распределения
    • Первые шаги в Q#. Алгоритм Дойча

    Краткое руководство. Создание генератора случайных чисел на основе квантовых вычислений в Azure Quantum

    В примерах в этом разделе используется пакет Microsoft Quantum Development Kit (классический QDK) и он еще не совместим с предварительной версией пакета средств разработки Azure Quantum (современный QDK). Дополнительные сведения о современном QDK см. в GitHub Wiki QSharp.

    Сведения о том, как использовать Azure Quantum для создания простого генератора случайных чисел на основе квантовых вычислений.

    Предварительные требования

    Для работы с этим учебником необходимы указанные ниже компоненты.

    • Учетная запись Azure с активной подпиской. Если у вас нет учетной записи Azure, зарегистрируйтесь бесплатно и зарегистрируйтесь для получения подписки с оплатой по мере использования.
    • Visual Studio Code, можно скачать и использовать бесплатно.
    • Расширение Microsoft QDK для VS Code.
    • Azure CLI и расширение CLI для Quantum.
    • Рабочая область Azure Quantum с включенным поставщиком IonQ. Дополнительные сведения см. в статье Создание рабочей области Azure Quantum.

    Создание проекта Q# в Visual Studio Code

    1. В Visual Studio Code откройте меню Вид и выберите пункт Палитра команд.
    2. Введите Q#: создание проекта.
    3. Выберите Standalone console application (Автономное консольное приложение).
    4. Выберите каталог для размещения проекта, например домашний каталог. Введите QuantumRNG в качестве имени проекта, а затем выберите Создать проект.
    5. В окне, появившемся в нижней части экрана, выберите Открыть новый проект.
    6. Вы увидите два файла: QuantumRNG.csproj, файл проекта и Program.qs, который содержит начальный код.
    7. Начните с открытия файла QuantumRNG.csproj и добавления ExecutionTarget свойства , которое дает отзывы во время разработки о совместимости программы с оборудованием IonQ.

      Exe net6.0 ionq.qpu   

    namespace QuantumRNG < open Microsoft.Quantum.Intrinsic; open Microsoft.Quantum.Measurement; open Microsoft.Quantum.Canon; @EntryPoint() operation GenerateRandomBits() : Result[] < use qubits = Qubit[4]; ApplyToEach(H, qubits); return MultiM(qubits); >> 

    Подготовка интерфейса командной строки Azure

    Затем подготовьте среду для запуска программы в созданной рабочей области.

    1. В меню Visual Studio Code выберите Терминал>Новый терминал.
    2. Войдите в Azure со своими учетными данными. Вы получите список подписок, связанных с вашей учетной записью.

    az login 

    az account set -s MySubscriptionID 

    az quantum workspace set \ -g MyResourceGroup \ -w MyWorkspace \ -l MyLocation \ -o table 

     Location Name ProvisioningState ResourceGroup StorageAccount Usable ---------- ----------- ------------------- --------------- ------------------ -------- MyLocation MyWorkspace Succeeded MyResourceGroup /subscriptions/. Yes 

    Примечание Параметр MyLocation в примере — это регион , указанный на странице Создание рабочей области Quantum при выполнении действий, описанных в разделе Создание рабочей области Azure Quantum. Регион и расположение являются синонимами. Значение параметра может быть выражено в смешанном регистре, заключенном в кавычки, например , -l «West US 2» или в нижнем регистре без пробелов или кавычек, таких как -l westus2 .

    az quantum target list -o table 

    В зависимости от выбранного поставщика вы увидите следующее:

    Provider Target-id Current Availability Average Queue Time (seconds) ------------ --------------------------------------------------- ---------------------- ------------------------------ ionq ionq.qpu Available 38715 ionq ionq.qpu.aria-1 Available 2042052 ionq ionq.simulator Available 2 microsoft-qc microsoft.estimator Available 0 quantinuum quantinuum.hqs-lt-s1 Available 232817 quantinuum quantinuum.hqs-lt-s1-apival Available 331 quantinuum quantinuum.hqs-lt-s2 Unavailable 0 quantinuum quantinuum.hqs-lt-s2-apival Available 7 quantinuum quantinuum.hqs-lt-s1-sim Available 19488 quantinuum quantinuum.hqs-lt-s2-sim Available 1577 quantinuum quantinuum.hqs-lt Available 0 quantinuum quantinuum.qpu.h1-1 Available 232817 quantinuum quantinuum.sim.h1-1sc Available 331 quantinuum quantinuum.qpu.h1-2 Unavailable 0 quantinuum quantinuum.sim.h1-2sc Available 7 quantinuum quantinuum.sim.h1-1e Available 19488 quantinuum quantinuum.sim.h1-2e Available 1577 quantinuum quantinuum.qpu.h1 Unavailable 0 rigetti rigetti.sim.qvm Available 5 rigetti rigetti.qpu.aspen-11 Unavailable 0 rigetti rigetti.qpu.aspen-m-3 Available 5 Microsoft microsoft.paralleltempering-parameterfree.cpu Available 0 Microsoft microsoft.paralleltempering.cpu Available 0 Microsoft microsoft.simulatedannealing-parameterfree.cpu Available 0 Microsoft microsoft.simulatedannealing.cpu Available 0 Microsoft microsoft.tabu-parameterfree.cpu Available 0 Microsoft microsoft.tabu.cpu Available 0 Microsoft microsoft.qmc.cpu Available 0 Microsoft microsoft.populationannealing.cpu Available 0 Microsoft microsoft.populationannealing-parameterfree.cpu Available 0 Microsoft microsoft.substochasticmontecarlo.cpu Available 0 Microsoft microsoft.substochasticmontecarlo-parameterfree.cpu Available 0 

    Примечание При отправке задания в Azure Quantum оно ожидается в очереди, пока поставщик не будет готов к запуску программы. Столбец targetСреднее время очереди команды list показывает, сколько секунд недавно выполнялись задания в очереди. Это позволяет предположить примерную длительность ожидания.

    Имитация выполнения программы в провайдере IonQ

    Перед запуском программы на реальном оборудовании рекомендуется сначала имитировать ее выполнение (если возможно, взяв за основу количество необходимых кубитов), чтобы убедиться, что ваш алгоритм выполняет правильные действия. К счастью, IonQ является идеальным и готовым к использованию симулятором.

    Result Frequency --------- ----------- ------------------------- [0,0,0,0] 0.06250000 ▐█ | [1,0,0,0] 0.06250000 ▐█ | [0,1,0,0] 0.06250000 ▐█ | [1,1,0,0] 0.06250000 ▐█ | [0,0,1,0] 0.06250000 ▐█ | [1,0,1,0] 0.06250000 ▐█ | [0,1,1,0] 0.06250000 ▐█ | [1,1,1,0] 0.06250000 ▐█ | [0,0,0,1] 0.06250000 ▐█ | [1,0,0,1] 0.06250000 ▐█ | [0,1,0,1] 0.06250000 ▐█ | [1,1,0,1] 0.06250000 ▐█ | [0,0,1,1] 0.06250000 ▐█ | [1,0,1,1] 0.06250000 ▐█ | [0,1,1,1] 0.06250000 ▐█ | [1,1,1,1] 0.06250000 ▐█ | 

    На ней показана равная частота для каждого из 16 возможных состояний для измерения 4 кубитов. Именно этот результат мы ожидали получить при использовании идеального симулятора. Это значит, что вы готовы к запуску программы на QPU.

    Запуск программы на оборудовании

    Чтобы запустить программу на оборудовании, используйте команду az quantum job submit отправки асинхронного задания . Как и команда execute , az quantum job submit компилирует и отправляет программу, но не будет ждать завершения выполнения. Мы рекомендуем использовать для запуска программ на оборудовании этот шаблон, так как на завершение некоторых заданий может уходить много времени. Чтобы получить представление о том, как долго это может быть, можно выполнить, az quantum target list -o table как описано выше.

    az quantum job submit \ --target-id ionq.qpu \ -o table 

     Name ID Status Target Submission time ---------- ------------------------------------ -------- -------- --------------------------------- QuantumRNG 5aa8ce7a-25d2-44db-bbc3-87e48a97249c Waiting ionq.qpu 2020-10-22T22:41:27.8855301+00:00 

    В таблице показано, что задание отправлено и ожидает его выполнения. Чтобы проверить состояние, используйте команду az quantum job show , обязательно перед этим заменив параметр job-id выходными данными ИД, полученными после выполнения предыдущей команды, например:

     az quantum job show \ -o table \ --job-id 5aa8ce7a-25d2-44db-bbc3-87e48a97249c 

     Name ID Status Target Submission time ---------- ------------------------------------ -------- -------- --------------------------------- QuantumRNG 5aa8ce7a-25d2-44db-bbc3-87e48a97249c Waiting ionq.qpu 2020-10-22T22:41:27.8855301+00:00 

    В конце концов вы увидите Status , что в предыдущей таблице изменится на Succeeded . После этого вы сможете узнать результаты выполнения задания, выполнив команду az quantum job output :

    az quantum job output \ -o table \ --job-id 5aa8ce7a-25d2-44db-bbc3-87e48a97249c 

    Result Frequency --------- ----------- ------------------------- [0,0,0,0] 0.05200000 ▐█ | [1,0,0,0] 0.07200000 ▐█ | [0,1,0,0] 0.05000000 ▐█ | [1,1,0,0] 0.06800000 ▐█ | [0,0,1,0] 0.04600000 ▐█ | [1,0,1,0] 0.06000000 ▐█ | [0,1,1,0] 0.06400000 ▐█ | [1,1,1,0] 0.07600000 ▐██ | [0,0,0,1] 0.04800000 ▐█ | [1,0,0,1] 0.06200000 ▐█ | [0,1,0,1] 0.07400000 ▐█ | [1,1,0,1] 0.08000000 ▐██ | [0,0,1,1] 0.05800000 ▐█ | [1,0,1,1] 0.06800000 ▐█ | [0,1,1,1] 0.05200000 ▐█ | [1,1,1,1] 0.07000000 ▐█ | 

    Полученная гистограмма может немного отличаться от предыдущей, но вы должны обнаружить, что состояния обычно наблюдаются с одинаковой частотой.

    Предварительные требования

    Для работы с этим учебником необходимы указанные ниже компоненты.

    • Учетная запись Azure с активной подпиской. Если у вас нет учетной записи Azure, зарегистрируйтесь бесплатно и зарегистрируйтесь для получения подписки с оплатой по мере использования.
    • Visual Studio Code, можно скачать и использовать бесплатно.
    • Расширение Microsoft QDK для VS Code.
    • Azure CLI и расширение CLI для Quantum.
    • Рабочая область Azure Quantum с включенным поставщиком Quantinuum. Дополнительные сведения см. в статье Создание рабочей области Azure Quantum.

    Создание проекта Q# в Visual Studio Code

    1. В Visual Studio Code откройте меню Вид и выберите пункт Палитра команд.
    2. Введите Q#: создание проекта.
    3. Выберите Standalone console application (Автономное консольное приложение).
    4. Выберите каталог для размещения проекта, например домашний каталог. Введите QuantumRNG в качестве имени проекта, а затем выберите Создать проект.
    5. В окне, появившемся в нижней части экрана, выберите Открыть новый проект.
    6. Вы увидите два файла: QuantumRNG.csproj, файл проекта и Program.qs, который содержит начальный код.
    7. Сначала откройте файл QuantumRNG.csproj и добавьте свойство ExecutionTarget , которое на этапе разработки будет информировать о совместимости программы с оборудованием Quantinuum.

      Exe net6.0 quantinuum.qpu.h1-1   

    namespace QuantumRNG < open Microsoft.Quantum.Intrinsic; open Microsoft.Quantum.Measurement; open Microsoft.Quantum.Canon; @EntryPoint() operation GenerateRandomBits() : Result[] < use qubits = Qubit[4]; ApplyToEach(H, qubits); return MultiM(qubits); >> 

    Подготовка интерфейса командной строки Azure

    Далее мы подготовим среду для запуска программы в созданной вами рабочей области.

    1. В меню Visual Studio Code выберите Терминал>Новый терминал.
    2. Войдите в Azure со своими учетными данными. Вы получите список подписок, связанных с вашей учетной записью.

    az login 

    az account set -s MySubscriptionID 

    az quantum workspace set \ -g MyResourceGroup \ -w MyWorkspace \ -l MyLocation \ -o table 

     Location Name ProvisioningState ResourceGroup StorageAccount Usable ---------- ----------- ------------------- --------------- ------------------ -------- MyLocation MyWorkspace Succeeded MyResourceGroup /subscriptions/. Yes 

    Примечание Параметр MyLocation в приведенном выше примере — это регион, указанный на странице Создание рабочей области Quantum при выполнении действий, описанных в разделе Создание рабочей области Azure Quantum. Регион и расположение являются синонимами. Значение параметра может быть выражено в смешанном регистре в кавычках, например -l «West US 2» , или в нижнем регистре без пробелов или кавычек, например -l westus2 .

    Примечание Имена target для методов проверки синтаксиса Quantinuum, эмуляторов и QKU недавно изменились. В этом разделе используются обновленные имена. Дополнительные сведения см. в разделе Поставщик Quantinuum .

    az quantum target list -o table 

    в результате использования которой будут доступны следующие выходные данные

    Provider Target-id Current Availability Average Queue Time (seconds) ------------ --------------------------------------------------- ---------------------- ------------------------------ ionq ionq.qpu Available 38715 ionq ionq.qpu.aria-1 Available 2042052 ionq ionq.simulator Available 2 microsoft-qc microsoft.estimator Available 0 quantinuum quantinuum.hqs-lt-s1 Available 232817 quantinuum quantinuum.hqs-lt-s1-apival Available 331 quantinuum quantinuum.hqs-lt-s2 Unavailable 0 quantinuum quantinuum.hqs-lt-s2-apival Available 7 quantinuum quantinuum.hqs-lt-s1-sim Available 19488 quantinuum quantinuum.hqs-lt-s2-sim Available 1577 quantinuum quantinuum.hqs-lt Available 0 quantinuum quantinuum.qpu.h1-1 Available 232817 quantinuum quantinuum.sim.h1-1sc Available 331 quantinuum quantinuum.qpu.h1-2 Unavailable 0 quantinuum quantinuum.sim.h1-2sc Available 7 quantinuum quantinuum.sim.h1-1e Available 19488 quantinuum quantinuum.sim.h1-2e Available 1577 quantinuum quantinuum.qpu.h1 Unavailable 0 rigetti rigetti.sim.qvm Available 5 rigetti rigetti.qpu.aspen-11 Unavailable 0 rigetti rigetti.qpu.aspen-m-3 Available 5 Microsoft microsoft.paralleltempering-parameterfree.cpu Available 0 Microsoft microsoft.paralleltempering.cpu Available 0 Microsoft microsoft.simulatedannealing-parameterfree.cpu Available 0 Microsoft microsoft.simulatedannealing.cpu Available 0 Microsoft microsoft.tabu-parameterfree.cpu Available 0 Microsoft microsoft.tabu.cpu Available 0 Microsoft microsoft.qmc.cpu Available 0 Microsoft microsoft.populationannealing.cpu Available 0 Microsoft microsoft.populationannealing-parameterfree.cpu Available 0 Microsoft microsoft.substochasticmontecarlo.cpu Available 0 Microsoft microsoft.substochasticmontecarlo-parameterfree.cpu Available 0 

    Примечание Отправленное в Azure Quantum задание будет ожидать в очереди, пока поставщик не будет готов запустить вашу программу. В столбце targetСреднее время очереди команды list показано, сколько секунд недавно выполнялось заданий в очереди. Это позволяет предположить примерную длительность ожидания.

    Проверьте программу в программе проверки синтаксиса Quantinuum

    Перед запуском программы на реальном оборудовании рекомендуется сначала запустить ее в квантовом симуляторе (если это возможно, на основе требуемого количества кубитов), чтобы убедиться, что алгоритм выполняет нужные действия.

    Чтобы запустить программу с помощью средства проверки синтаксиса Quantinuum, отправьте следующую команду:

    az quantum execute \ --target-id quantinuum.sim.h1-1sc \ -o table 

    Эта команда компилирует программу, отправляет ее в средство проверки синтаксиса Quantinuum и ожидает завершения моделирования программы. После этого выводится гистограмма, похожая на следующую:

    Result Frequency --------- ----------- ---------------------- [0,0,0,0] 1.00000000 |████████████████████| 

    Глядя на гистограмму, можно заметить, что генератор случайных чисел каждый раз возвращал 0, что не очень случайно. Это связано с тем, что, хотя средство проверки синтаксиса гарантирует, что код будет успешно выполняться на оборудовании Quantinuum, он также возвращает 0 для каждого квантового измерения. Для генератора по-настоящему случайных чисел необходимо запустить цепь на квантовом оборудовании.

    Запуск программы на оборудовании

    Для запуска программы на оборудовании мы будем использовать команду асинхронной отправки заданий az quantum job submit . Подобно команде execute , эта команда скомпилирует и отправит вашу программу, но не будет ожидать завершения ее выполнения. Мы рекомендуем использовать для запуска программ на оборудовании этот шаблон, поскольку на завершение некоторых заданий может уходить много времени. Чтобы получить представление о том, как долго это может быть, можно выполнить, az quantum target list -o table как описано выше.

    az quantum job submit \ --target-id quantinuum.qpu.h1-1 \ -o table 

     Name ID Status Target Submission time ---------- ------------------------------------ -------- -------- --------------------------------- QuantumRNG b4d17c63-2119-4d92-91d9-c18d1a07e08f Waiting quantinuum.qpu.h1-1 2020-01-12T22:41:27.8855301+00:00 

    В таблице показано, что задание отправлено и ожидает выполнения своей очереди. Чтобы проверить состояние, используйте команду az quantum job show , обязательно перед этим заменив параметр job-id выходными данными ИД, полученными после выполнения предыдущей команды, например:

     az quantum job show \ -o table \ --job-id b4d17c63-2119-4d92-91d9-c18d1a07e08f 

     Name ID Status Target Submission time ---------- ------------------------------------ -------- -------- --------------------------------- QuantumRNG b4d17c63-2119-4d92-91d9-c18d1a07e08f Waiting quantinuum.qpu.h1-1 2020-10-22T22:41:27.8855301+00:00 

    Значение Status из приведенной выше таблицы меняется на Succeeded . После этого вы сможете узнать результаты выполнения задания, выполнив команду az quantum job output :

    az quantum job output \ -o table \ --job-id b4d17c63-2119-4d92-91d9-c18d1a07e08f 

    Result Frequency --------- ----------- ------------------------- [0,0,0,0] 0.05200000 ▐█ | [1,0,0,0] 0.07200000 ▐█ | [0,1,0,0] 0.05000000 ▐█ | [1,1,0,0] 0.06800000 ▐█ | [0,0,1,0] 0.04600000 ▐█ | [1,0,1,0] 0.06000000 ▐█ | [0,1,1,0] 0.06400000 ▐█ | [1,1,1,0] 0.07600000 ▐██ | [0,0,0,1] 0.04800000 ▐█ | [1,0,0,1] 0.06200000 ▐█ | [0,1,0,1] 0.07400000 ▐█ | [1,1,0,1] 0.08000000 ▐██ | [0,0,1,1] 0.05800000 ▐█ | [1,0,1,1] 0.06800000 ▐█ | [0,1,1,1] 0.05200000 ▐█ | [1,1,1,1] 0.07000000 ▐█ | 

    Итоговая гистограмма может немного отличаться от показанной выше, но вы должны увидеть, что состояния обычно имеют одинаковую частоту.

    Предварительные требования

    Для работы с этим учебником необходимы указанные ниже компоненты.

    • Учетная запись Azure с активной подпиской. Если у вас нет учетной записи Azure, зарегистрируйтесь бесплатно и зарегистрируйтесь для получения подписки с оплатой по мере использования.
    • Visual Studio Code, можно скачать и использовать бесплатно.
    • Расширение Microsoft QDK для VS Code.
    • Azure CLI и расширение CLI для Quantum.
    • Рабочая область Azure Quantum с включенным поставщиком Rigetti . Дополнительные сведения см. в статье Создание рабочей области Azure Quantum.

    Создание проекта Q# в Visual Studio Code

    1. В Visual Studio Code откройте меню Вид и выберите пункт Палитра команд.
    2. Введите Q#: создание проекта.
    3. Выберите Standalone console application (Автономное консольное приложение).
    4. Выберите каталог для размещения проекта, например домашний каталог. Введите QuantumRNG в качестве имени проекта, а затем выберите Создать проект.
    5. В окне, появившемся в нижней части экрана, выберите Открыть новый проект.
    6. Вы увидите два файла: QuantumRNG.csproj, файл проекта и Program.qs, содержащий начальный код.
    7. Начните с открытия файла QuantumRNG.csproj и добавления ExecutionTarget свойства , которое предоставляет обратную связь во время разработки о совместимости вашей программы с оборудованием Rigetti.

      Exe net6.0 rigetti.qpu.aspen-m-3   

    namespace QuantumRNG < open Microsoft.Quantum.Intrinsic; open Microsoft.Quantum.Measurement; open Microsoft.Quantum.Canon; @EntryPoint() operation GenerateRandomBits() : Result[] < use qubits = Qubit[4]; for q in qubits < H(q); >return MeasureEachZ(qubits); > > 

    Примечание При достижении одинаковых результатов пример кода для Rigetti отличается от других примеров в этом кратком руководстве: для выполнения квантовой for H операции и MeasureEachZ измерения результатов используется цикл . В настоящее время Rigetti targets не поддерживает изменяемые массивы и, следовательно, не поддерживает ApplyToEach операции или MultiM .

    Подготовка интерфейса командной строки Azure

    Далее мы подготовим среду для запуска программы в созданной вами рабочей области.

    1. В меню Visual Studio Code выберите Терминал>Новый терминал.
    2. Войдите в Azure со своими учетными данными. Вы получите список подписок, связанных с вашей учетной записью.

    az login 

    az account set -s MySubscriptionID 

    az quantum workspace set \ -g MyResourceGroup \ -w MyWorkspace \ -l MyLocation \ -o table 

     Location Name ProvisioningState ResourceGroup StorageAccount Usable ---------- ----------- ------------------- --------------- ------------------ -------- MyLocation MyWorkspace Succeeded MyResourceGroup /subscriptions/. Yes 

    Примечание Параметр MyLocation в приведенном выше примере — это регион, указанный на странице Создание рабочей области Quantum при выполнении действий, описанных в разделе Создание рабочей области Azure Quantum. Регион и расположение являются синонимами. Значение параметра может быть выражено в смешанном регистре, окруженном кавычками, например , -l «West US 2» или в нижнем регистре без пробелов или кавычек, таких как -l westus2 .

    az quantum target list -o table 

    Результат будет выглядеть примерно так:

    Provider Target-id Current Availability Average Queue Time ---------- ------------------------------------------- -------------------- -------------------- ionq ionq.qpu Available 0 ionq ionq.qpu.aria-1 Available 0 ionq ionq.simulator Available 0 microsoft-q c microsoft.estimator quantinuum quantinuum.qpu.h1-1 Available 0 quantinuum quantinuum.qpu.h1-1sc Available 0 quantinuum quantinuum.qpu.h1-1e Available 0 quantinuum quantinuum.qpu.h1-2 Available 0 quantinuum quantinuum.qpu.h1-2sc Available 0 quantinuum quantinuum.qpu.h1-2e Available 0 rigetti rigetti.sim.qvm Available 5 rigetti rigetti.qpu.aspen-11 Unavailable 0 rigetti rigetti.qpu.aspen-m-3 Available 5 

    Примечание Отправленное в Azure Quantum задание будет ожидать в очереди, пока поставщик не будет готов запустить вашу программу. В столбце targetСреднее время очереди команды list показано, сколько секунд недавно выполнялось заданий в очереди. Это позволяет предположить примерную длительность ожидания.

    Имитация программы в симуляторе Rigetti

    Перед запуском программы на реальном оборудовании рекомендуется сначала запустить ее в квантовом симуляторе (если это возможно, на основе требуемого количества кубитов), чтобы убедиться, что алгоритм выполняет нужные действия.

    Чтобы запустить программу с помощью симулятора Rigetti QVM, отправьте следующую команду:

    az quantum execute \ --target-id rigetti.sim.qvm \ -o table 

    Эта команда компилирует программу, отправляет ее в симулятор QVM Rigetti и ожидает завершения моделирования программы. После этого выводится гистограмма, похожая на следующую:

    Result Frequency ------------ ----------- ----------------------[0, 0, 0, 0] 0.06600000 |█ | [1, 1, 1, 1] 0.05800000 |█ | [0, 0, 0, 1] 0.06000000 |█ | [0, 1, 1, 1] 0.07400000 |█ | [0, 0, 1, 1] 0.05800000 |█ | [1, 0, 1, 0] 0.06400000 |█ | [1, 1, 0, 1] 0.07600000 |██ | [1, 1, 0, 0] 0.04400000 |█ | [0, 1, 0, 1] 0.06000000 |█ | [1, 0, 1, 1] 0.07400000 |█ | [0, 1, 0, 0] 0.05800000 |█ | [0, 0, 1, 0] 0.07200000 |█ | [0, 1, 1, 0] 0.06800000 |█ | [1, 1, 1, 0] 0.05600000 |█ | [1, 0, 0, 0] 0.05600000 |█ | [1, 0, 0, 1] 0.05600000 |█ | 

    Запуск программы на оборудовании

    Для запуска программы на оборудовании мы будем использовать команду асинхронной отправки заданий az quantum job submit . Подобно команде execute , эта команда скомпилирует и отправит вашу программу, но не будет ожидать завершения ее выполнения. Мы рекомендуем использовать для запуска программ на оборудовании этот шаблон, так как на завершение некоторых заданий может уходить много времени. Чтобы получить представление о том, как долго это может быть, можно выполнить команду az quantum target list -o table , как описано выше.

    az quantum job submit \ --target-id rigetti.qpu.aspen-m-3 \ -o table 

     Name ID Status Target Submission time ---------- ------------------------------------ -------- -------- --------------------------------- QuantumRNG b4d17c63-2119-4d92-91d9-c18d1a07e08f Waiting rigetti.qpu.aspen-m-3 2020-01-12T22:41:27.8855301+00:00 

    В таблице показано, что задание отправлено и ожидает выполнения своей очереди. Чтобы проверить состояние, используйте команду az quantum job show , обязательно перед этим заменив параметр job-id выходными данными ИД, полученными после выполнения предыдущей команды, например:

     az quantum job show \ -o table \ --job-id b4d17c63-2119-4d92-91d9-c18d1a07e08f 

     Name ID Status Target Submission time ---------- ------------------------------------ -------- -------- --------------------------------- QuantumRNG b4d17c63-2119-4d92-91d9-c18d1a07e08f Waiting rigetti.qpu.aspen-m-3 2020-10-22T22:41:27.8855301+00:00 

    В конце концов вы увидите Status в приведенной выше таблице изменение на Succeeded . После этого вы сможете узнать результаты выполнения задания, выполнив команду az quantum job output :

    az quantum job output \ -o table \ --job-id b4d17c63-2119-4d92-91d9-c18d1a07e08f 

    Result Frequency --------- ----------- ------------------------- [0,0,0,0] 0.05200000 ▐█ | [1,0,0,0] 0.07200000 ▐█ | [0,1,0,0] 0.05000000 ▐█ | [1,1,0,0] 0.06800000 ▐█ | [0,0,1,0] 0.04600000 ▐█ | [1,0,1,0] 0.06000000 ▐█ | [0,1,1,0] 0.06400000 ▐█ | [1,1,1,0] 0.07600000 ▐██ | [0,0,0,1] 0.04800000 ▐█ | [1,0,0,1] 0.06200000 ▐█ | [0,1,0,1] 0.07400000 ▐█ | [1,1,0,1] 0.08000000 ▐██ | [0,0,1,1] 0.05800000 ▐█ | [1,0,1,1] 0.06800000 ▐█ | [0,1,1,1] 0.05200000 ▐█ | [1,1,1,1] 0.07000000 ▐█ | 

    Полученная гистограмма может немного отличаться от приведенной выше, но вы должны обнаружить, что состояния обычно наблюдаются с одинаковой частотой.

    Если при работе с Azure Quantum возникнет ошибка, ознакомьтесь с нашим списком распространенных проблем.

    Дальнейшие действия

    В этом кратком руководстве показано, как приступить к работе с программами Q# в разных симуляторах квантовых вычислений и квантовых процессорах. Дополнительные сведения о доступных поставщиках см. в обзорной документации поставщика квантовых вычислений.

    Мы рекомендуем продолжить работу, изучив дополнительные сведения о различных типах targets в Azure Quantum, которые определяют типы программ Q#, которые можно запускать у конкретного поставщика. Вас также может заинтересовать вопрос отправки заданий Q# с помощью Python, записных книжек Jupyter или Azure CLI.

    Ищете дополнительные примеры для запуска? Ознакомьтесь с каталогом примеров для Azure Quantum.

    Наконец, если вы хотите узнать больше о написании программ на Q#, см. руководство пользователя по языку программирования Q#.

    Как указать значение квантовых чисел для canon

    При свете энергосберегайки на 26 ватт метров в 3 я снимаю на 1600 на !/60 1.8 . вечером могу выложить, так-что что-то с 6400 у вас не-то
    а мой кадр снят внутри шкафа, да свет дневной, но рассеяный. просто день ведь зато исо 6400 без всякой коррекции и обработки. екзиф там есть и от цвета еще что-то осталось

    aleck 29-01-2012 15:05

    Господа, это всё круто конечно. Но что вы там сравнивать собрались, мне непонятно ))) Если вы хотите сравнивать системы по шумам, вам надо определиться как минимум с тремя вещами:
    — одинаковая степень шумодавления (проще всего отключить)
    — одинаковая коррекция резкости (тоже проще сделать нулевой)
    — ресайз картинки до одного размера в пикселах. (например до 21 Мп)

    Если этого не сделать, то я вам с любыми камерами в тестах получу какие угодно результаты )))

    Но даже при соблюдении этих условий результаты тестов не могут адекватно охарактеризовать картинки с разных камер. Дело в том, что шумы нельзя оценивать в отрыве от четкости картинки. Вполне может оказаться, что одна камера будет давать более шумную картинку, но с мелкими деталями, а другая, менее шумную, но чуть мыльную. В идеале надо брать одну и ту же оптику и снимать тестовые картинки на одних и тех же параметрах.

    Шумы нельзя рассматривать в отрыве от разрешающей способности!

    Dm! 29-01-2012 15:32

    quote: Originally posted by aleck:
    В идеале надо брать одну и ту же оптику и снимать тестовые картинки на одних и тех же параметрах.

    что собственно я писал уже выше! предлагаю взять Никоновскую оптику и через переходник использовать на Кэнон.

    пока у меня не приехал Д50, но могу дать переходник для теста и если понадобится полтинник мануальный 1,8. НО, на Д50 максимальное ИСО 1600. так что объективной картинки не увидим, хотя все же интересна картинка в одинаковых условиях и с кэнона!

    sasm 29-01-2012 15:44

    quote: Originally posted by aleck:
    Но даже при соблюдении этих условий результаты тестов не могут адекватно охарактеризовать картинки с разных камер. Дело в том, что шумы нельзя оценивать в отрыве от четкости картинки.
    [b]Шумы нельзя рассматривать в отрыве от разрешающей способности!
    [/B]

    Какая еще разрешающая способность на 6400 ?
    на что либо большее чем 2 мп или 10х15 не стоит и рассчитывать
    А в случае кенона и никона и на цвет тоже

    Amigo 29-01-2012 15:56

    quote: Originally posted by aleck:

    — одинаковая степень шумодавления (проще всего отключить)

    срать! я на отдыхе в жипег снимаю и пусть работа шумодава будет видна

    quote: Originally posted by aleck:

    — ресайз картинки до одного размера в пикселах. (например до 21 Мп)

    опиши как это сделать на 10,12 и 13 мпикс
    кстати на ФФ я хотел ставить 85мм на кропе 50мм
    и все же Саш после твоей фразы «разница между кропом и ФФ В 1 СТОП»
    нет доверия в к твоим словам
    я между двумя кропами 1,6 нашел разницу в 4 стопа
    если я ошибаюсь скажи в чем

    aleck 29-01-2012 16:47

    quote: Originally posted by Amigo:

    срать! я на отдыхе в жипег снимаю и пусть работа шумодава будет видна

    Проблема не в том, будет видна работа шумодава или не будет. А в том, чтобы для всех тестовых снимков с разных камер она была одинаковой. Иначе сравнение не имеет смысла. Самое простое — это договориться просто отключить любое шумодавление (если речь про jpeg), либо точно определить параметры конвертирования, если съемка в raw.

    quote: Originally posted by Amigo:
    опиши как это сделать на 10,12 и 13 мпикс

    Увеличить картинку в ФШ, чтобы все тестовые картинки имели один и то же размер в пикселах.

    quote: Originally posted by Amigo:

    кстати на ФФ я хотел ставить 85мм на кропе 50мм
    и все же Саш после твоей фразы «разница между кропом и ФФ В 1 СТОП»
    нет доверия в к твоим словам

    А ты спрашивай, я отвечу )
    Я и сейчас подпишусь под этой фразой. Чувствительность полнокадровой и кропнутой матрицы, изготовленной по одинаковой технологии отличается на 1 ступень. Это прямое следствие того факта, что кроп имеет вдвое меньшую площадь, чем полный кадр. Если что-то смущает, а объясню.

    quote: Originally posted by Amigo:
    я между двумя кропами 1,6 нашел разницу в 4 стопа
    если я ошибаюсь скажи в чем

    Не очень понимаю о каком именно сравнении идет речь. Но допускаю, что если сравнивать некорректно, то я могу и «между одной камерой» найти разницу шумах )

    Amigo 29-01-2012 17:09

    quote: Originally posted by aleck:

    Чувствительность полнокадровой и кропнутой матрицы, изготовленной по одинаковой технологии отличается на 1 ступень

    не важно по каким технология изготовлены 400д и 5 д
    разница в светочувствительности между ними более чем 1 ступень
    давайте по теме
    кто может сегодня вечером или завтра вечером
    500д тоже интересно потестить

    aleck 29-01-2012 17:20

    quote: Originally posted by aleck:

    не важно по каким технология изготовлены 400д и 5 д
    разница в светочувствительности между ними более чем 1 ступень

    Я говорю о фундаментальном различии. В действительности же можно намерять все, что угодно, потому что а) технологии производства матриц отличаются, б) применяется некорректная методика тестирования. О том как измерять правильно, написал выше.

    Amigo 29-01-2012 17:23

    quote: Originally posted by aleck:

    я могу и «между одной камерой» найти разницу шумах

    конечно можешь Саш
    снимешь рав + жипег
    и затем рав полирнешь в хорошем шумодаве и в редкаторе подкорректируешь
    и утебя будет разница в шумах и прочих глистограммах))

    aleck 29-01-2012 17:25

    вот о том же и я говорю )
    Надо сначала договориться о методике, а уже потом снимать, тестировать и измерять. Выкладывание снимков с указанием ISO — это профанация. На основании этого нельзя сказать что-то определенное о характеристиках камеры.

    Amigo 29-01-2012 17:36
    
    давай занимайся наукой а я буду заниматься профанацией
    сравним потом результаты
    aleck 29-01-2012 18:40

    ну, тогда надо давать себе отчет, что это просто такая веселая затея «давайте как-нибудь потестируем наши камеры». Ничего плохого в этом нет. Просто надо понимать, что из результатов таких тестов никаких общих выводов сделать не получится.

    Т.е. в общем случае нельзя будет сказать, что камера А шумит меньше, чем камера Б. Потому что при желании можно намерять что угодно, например, можно намерять, что кроп шумит меньше, чем ФФ. )

    Mr D 29-01-2012 20:18
    
    Про ISO. Международный интститут стандартизации — это и есть ISO.

    У каждой матрицы есть своя предельная ёмкость, которая расчитывается по определённой методике. Например у Canon 5D один элемент матрицы содержит максимум 70000 электронов. После 12 битного АЦП (аналого-цифровой преобразователь) эти 70000 электронов превращаются в число 4095 в RAW-файле. Когда света мало, а на каждые два фотона примерно один выбитый электрон, поднимают ISO. Это просто битовый сдвиг перед АЦП. То есть ISO200 — сдвиг на оин бит или умножение на два. ISO400-на 2 бита или умножение на 4 и так далее. Если электронов в ячейках мало, допустим в соседних ячейках 40,41,42,43,44 электрона, то есть непрерывный ряд, то ISO800 даёт нам умножение на 8, то есть ряд превращается в 320, 328, 336, 344 . Теперь вместо непрерывной тональности видим гребенку. Предельное ISO для 5D — 400. Дальше гребенка. У кропнутых камер ёмкость матрицы меньше из-за их размера, поэтому гребенка появляется раньше на ISO200. Про тепловые шумы пока не буду, приходите на Фотоакадемию.

    Mr D 29-01-2012 20:19
    
    p.s. Дробное ISO применяют после АЦП, что вносит еще дополнительные погрешности округления.
    Dm! 29-01-2012 20:47

    Виктор, ты еще больше запутал
    без сомнения расписал всё и это правильно, но Амиго хотел провести тест как обыватель и просто сравнить картинку на разных ИСО с разных бюджетных камер. именно свой тест, что бы было что показать и как камеры ведут себя чисто без всяких настроек.
    скорее всего тест проходил бы с настройками камеры по дефолту и рав и джепег . ну я так представил. может Саня что то другое имел в виду.

    Mr D 29-01-2012 21:12

    Смысл тестирования? Алгоритмов шумоподавления? Так они всяко в фотошопе лучше работают. Снимайте в RAW и будет вам счастье. А законов математики никто не отменял.

    Правило простое — в темноте снимаем в целых RAW (200,400,800,1600,3200) максимально светлые кадры, а потом убираем шумы в фильтрах или плагинах фотошопа. Потому что гребёнка полезет до АЦП.

    Если получите темные кадры и будете увеличивать яркость уже в редакторе, то полезет дополнительная гребенка из маленьких цифр. Простая же арифметика.

    Amigo 29-01-2012 21:15

    я предлагаю собраться уже
    у меня в соцгороде р-он старый Юпитер
    кто в какое время может пишите
    завтра или в среду вечером кто нибудь желает ?

    aleck 29-01-2012 22:26

    quote: Originally posted by Mr D:
    p.s. Дробное ISO применяют после АЦП, что вносит еще дополнительные погрешности округления.

    В нашем случае этим можно спокойно пренебречь )

    quote: Originally posted by Mr D:
    Это просто битовый сдвиг перед АЦП. То есть ISO200 — сдвиг на оин бит или умножение на два.

    Мне всегда было интересно, как схемотехнически реализовано «усиление» сигнала с матрицы. Если я правильно понимаю весь сигнал оцифровывается с избыточной точностью на 16-битном АЦП (65536 уровней квантования), а затем, в зависимости от значения ISO выбирается, какие именно 12 бит из 16 идут в raw-файл. Я не сильно наврал?

    quote: Originally posted by Mr D:
    Предельное ISO для 5D — 400. Дальше гребенка.

    Это ты имеешь в виду гребенка, которую будет присутствовать в 12-битном представлении?

    mickola 30-01-2012 12:03

    Amigo, лучше покажи в чём различие не в ISO фотиков. А в глубине цветов. Думаю это многим интересно будет. А про ISO тема заезженная до дыр.
    Возьмём такие близкие фотики как
    Canon EOS 5D. Глубина цвета 36 бит
    Canon EOS 5D Mark II..Глубина цвета 42 бит
    данные взял с яндекса об глубине цвета.

    Mr D 30-01-2012 12:20

    Сам сенсор цифровой. Квантовая эффективность — 0.5 То есть, на два кванта света — один электрон. Камера как бы дважды цифровая — сначала отсчеты на сенсоре, потом АЦП переваривает их в числа RAW в соответствии с битностью. Увеличение ISO не увеличивает количество света, а лишь умножает количество этих электронов на 2, на 4 и так далее. Если этих электронов мало, то при умножении на 4, 8, 16, 32 появляется гребенка, непрерывный ряд чисел исчезает. Плюсом шумы — шум квантования на сенсоре, шум этого усилителя, просто тепловой шум (электроны лезут сами по себе без света) и шум квантования на АЦП. Вот это все вылазит при малом количестве света. То есть чем больше полная ёмкость сенсора в электронах, тем меньше шум в RAW.

    Mr D 30-01-2012 12:21
    
    p.s. Поэтому мы и любим первый пятак!
    Mr D 30-01-2012 12:27
    
    p.p.s. Про стандарт ISO хотя бы почитайте http://en.wikipedia.org/wiki/F. _exposure_index
    aleck 30-01-2012 03:19
    
    Это всё понятно )
    Полный кадр и крупный пиксель дают о себе знать.

    Я не могу понять о какой гребенке ты говоришь и почему ISO 400 предельное. В каком смысле т.е. предельное?

    По моему разумению дело происходит так: допустим предельная ёмкость пиксела матрицы 2^16 (для удобства). Забудем пока про тепловые шумы и представим, что у нас идеальный усилительный тракт и идеальный АЦП. Чтобы представить в цифровом виде сигал с матрицы нам понадобится не более 16 бит, при этом младший бит будет содержать информацию о единичных электронах в ячейке. Т.е. более точно информацию о яркости пиксела представить невозможно.

    Далее, в raw-файл попадает 12-битная инфомация о яркости пиксела. Т.е. 4 младших разряда нашего гипотетического 16-битного представления попросту отсекаются. Это ISO 100. Но у нас есть запас 4 бита, каждый из который дает 1 ступень ISO.
    ISO 200 отрезаем 3 младших бита
    ISO 400 отрезаем 2 младших бита
    ISO 800 отрезаем младший бит
    ISO 1600 ничего не отрезаем. (Предельное значение ISO)
    ISO 3200 — гребенка. Т.е. младший бит не содержит информации.

    Т.е., выражаясь твоими терминами, у нас был 1 электрон, который при ISO 1600 превратился в значение 16 — минимальное значение, которое может зафиксировать 12-битный АЦП, при максимальном значении сигнала 65536. Т.е. 16/65536 = 1/4096

    Понятно, что это гипотетическая ситуация и в действительности 2-3 младших бита содержат информацию только о шумах (т.е. никакого изображения там уже нет). Собственно, поэтому сейчас в raw используется 14-битное представление (и то «с запасом», что называется).

    Mr D 30-01-2012 03:31

    Про «глубину» цвета.
    У Canon 5D — 12 бит АЦП. Над каждым пикселем матрицы стоит цветной фильтр — красный, зелёный или голубой. Поэтому каждый цвет может быть представлен числом от 0 до 4095 или другими словами 12-и битным числом. 3 канала цвета по 12 бит — 36 бит.

    У Canon 5D Mark II — 14 бит АЦП. Соответственно 3 * 14 = 42 бита.

    RAW конвертеры преобразуют эти значения либо в 8-и битный jpg для Web, либо в 16-и битный TIFF для качественной печати, как у меня.

    Mr D 30-01-2012 03:40
    
    Предельное значение ISO — когда 1 электрон превращается в 1 RAW файла.
    Mr D 30-01-2012 03:51

    На более высоких ISO каждый электрон будет уже производить 2, 4, 8, 16 отсчетов АЦП. Вот отсюда гребёнка и растет.

    На втором пятаке 64000 электронов максимум. В средней зоне по экспонометру -3.7 стопа от максимума примерно 5000 электронов. Это при ISO 100. Средняя зона в 14-и битном раве число 1260. То есть примерно 4 электрона на один отсчет RAW. Соответственно при ISO400 — это будет 1 электрон в один отсчет. Дальше — гребенка.

    aleck 30-01-2012 03:53

    Ну, так у меня получилось, что если максимальная емкость 64K электронов, то предельное ISO 1600. Расчет показал ранее.

    Хотя я понимаю, что шум квантования в данном случае значительно меньше тепловых и иных шумов )

    aleck 30-01-2012 03:56

    quote: Originally posted by Mr D:
    Средняя зона в 14-и битном раве число 1260. То есть примерно 4 электрона на один отсчет RAW.

    А-а, ты 14-битный считаешь ) Ну тогда без вопросов. 16-14 = 2 бита про запас, т.е. четырехкратное усиление сигнала.

    Хотя реальное ограничение наступает всё же не по шумам квантования, а по тепловым шумам, так что в реальности этим можно не париться )

    Mr D 30-01-2012 04:06

    Так там та же гребенка. Мы доходим до предела квантования — есть в ячейке 1 электрон, либо его нет. Чисто вероятностный процесс.
    Суть в том, что если нет света, то хоть заумножайся.

    Mr D 30-01-2012 04:08

    Все на целочисленной арифметике построено. Вот она и стучит. Единственный RAW конвертер с плавающей точкой — RPP, его и пользую в особых творческих случаях.

    aleck 30-01-2012 04:52

    Честно говоря не очень понимаю, как помогает плавающая точка. Во-первых, проблема гребенки в самой природе квантования, а не в том, что сигнал округляют до целых разрядов. А во-вторых, как я понимаю, уровень теплового шума по-любому перекрывает шум квантования. Т.е. сигнала (ни в виде в виде гребенки, ни в каком другом виде) от этих единичных электронов мы все равно никогда не увидим.

    Иными словами я вот не представляю себе пример, когда имено плавающая точка была бы заметна.

    searching 30-01-2012 10:54

    Доволен Сони а35 — легкий, бал снимал на исо 1600, заодним видео шикарное снимает — киношное качество.
    Могу завтра с ним прийти в любое время.

    searching 30-01-2012 14:19

    quote: Originally posted by aleck:

    Иными словами я вот не представляю себе пример, когда имено плавающая точка была бы заметна.

    Цитирую: «RPP — один из немногих в мире конверторов, который использует внутренние математические операции с плавающей точкой. Что это такое, можно проиллюстрировать следующим образом.

    5 / 2 = 2,5 (такой результат получается в RPP)
    5 / 2 = 2 (такой результат получается во всех остальных конверторах)

    Целочисленная математика, в отличие от математики с плавающей точкой, откидывают всё, что после запятой. В итоге в процессе конвертации и обработки накапливаются ошибки, которые снижают качество итоговой картинки. Единственным плюсом неточной математики является скорость.»

    Mr D 30-01-2012 15:31
    
    На реальных фото конечно меньше видно, но вот на тестах
    aleck 30-01-2012 19:43

    Да, теперь согласен ) Я как-то не додумал, что дробные значения проявляются себя косвенно. Например, на сюжетах с наложением мелких структур, там где имеет место интерференция, нецелочисленные алгоритмы не дают артефактов, связанных с ошибкой округления при наложении частот.

    Пример хоть и весьма синтетический, но очень иллюстративный.
    В реальной жизни, правда в 99% случаев не понадобится )

    Mr D 30-01-2012 20:26
    
    В Глянце я RPP поставил на Мак, можно пробовать.
    Андрес 31-01-2012 09:25
    
    D50 у меня есть.
    Mr D 31-01-2012 13:56
    
    Вот еще отношение сигнал/шум для разных камер при ISO100.
    А у вас какая методика сравнения будет?
    Андрес 31-01-2012 15:27
    
    Что обозначают синенькая и рыженькая полосочки на графике?
    Mr D 31-01-2012 16:42

    Две теоретические модели. Коричневая для старых сенсоров до 2008 года выпуска с плотностью 1700 электронов на квадратный микрон, голубая — новые сенсоры с 1900 электронов на квадратный микрон.

    Андрес 31-01-2012 20:10

    Mr D: а разве перед АЦП не идет аналогового усиления, коэффициент которого меняется в зависимости от установки чувствительности? Чтобы не было грубого отбрасывания лишних разрядов.

    Mr D 31-01-2012 22:02

    Уровни в ячейке квантованные — есть электрон — нет электрона. После накопления заряда в ячейках строки вся строка считывается чохом как последовательный аналоговый сигнал но с квантованными уровнями. Малошумящий усилитель стоит перед АЦП — но ему удобнее с квантованными уровнями умножать их в 2, 4, 8, 16 раз. Дробное ISO осуществляется уже после АЦП. Как то так. Подробнее уже к производителям или проводить эксперименты с фотоаппаратом, как с чёрным ящиком. libRAW в помощь.

    Amigo 31-01-2012 22:50

    quote: Originally posted by Mr D:

    новые сенсоры с 1900 электронов на квадратный микрон

    что дает увеличение плотности?
    Mr D 31-01-2012 23:32
    
    Увеличивается отношение сигнал/шум, возможность снимать на более высоких ISO.
    Amigo 01-02-2012 03:07

    quote: Originally posted by Mr D:
    Увеличивается отношение сигнал/шум, возможность снимать на более высоких ISO.

    ну на 400 д скажем было 1700 на 1100д стало 1900 увеличение соотношения сигнал шум на 12 процентов дало прирост чувствительности на 4 стопа ?

    Mr D 01-02-2012 03:24
    
    Нет конечно. Просто стало меньше шумов на 12%
    Amigo 01-02-2012 12:13

    ну я то говорил про джипег и шумодав
    шумов меньше и цветонасыщенности тоже
    хотя цвет тянется и шумы не лезут

    searching 01-02-2012 14:19
    
    на 1100д удалось увеличить полезную площадь каждого отдельного фотоэлемента
    aleck 01-02-2012 15:08

    quote: Originally posted by Amigo:
    ну я то говорил про джипег и шумодав
    шумов меньше и цветонасыщенности тоже
    хотя цвет тянется и шумы не лезут

    В смысле, по твоему мнению, у 1100D картинка по шумам на 4 стопа лучше, чем у 400D ?

    Mr D 01-02-2012 15:55

    Вот он АЦП, который ставят на Nikin D3 и D3s . График из даташита, отклонение от линейности в битах. В средних тонах 4-5к — отклонение от линейности 5-7 бит. Как то так всё работает.

    Amigo 01-02-2012 21:40

    quote: Originally posted by aleck:

    В смысле, по твоему мнению, у 1100D картинка по шумам на 4 стопа лучше, чем у 400D ?

    разница между исо 1600 и 6400 =2 стопа
    разинца между 1/25 и 1/60= более чем 1 стоп
    +на 1100д картинка ярче получилась
    так у меня получилось 4 стопа
    я что-то не так считаю ?

    aleck 01-02-2012 23:04
    
    Может и так.
    Просто я не понимаю что и как именно ты считаешь. Поэтому ответить не могу.

    Если речь идет о сравнении двух камер, то в домашних условиях наиболее корректным способом это можно сделать следующим образом:

    1. Берешь серую карту, или еще лучше миру с клиньями.
    2. Определяешь освещение и экспопараметры, экспонируя её до средне-серого уровня (ну, или до того, на котором хочешь провести сравнение. Так уж сложилось, что шум цифровых камер более всего заметен в тенях).
    3. Делаешь на обе камеры raw-снимок на одинаковых экспопараметрах. Желательно с одной и той же оптикой (если возможно).
    4. Тащишь raw в конвертер. Выключаешь нафиг абсолютно все, что связано с шумодавлением и резкостью.
    5. Если картинки отличаются по яркости, дотягиваешь параметром Exposure одну до другой. Запоминаешь полученное значение.
    6. Экспортируешь все в psd. Открываешь в ФШ. Увеличиваешь меньшую по разрешению картинку до размеров большей, или наоборот.

    7. Вот теперь под лупой сравниваешь уровень шумов.

    Если по яркости, резкости и уровню шумов картинки совпадают, значит степень пригодности камер для съемки с низким освещением одинаковая.

    Если картинки отличаются, то качественная интерпретация будет следующей:
    (предполагается, что отличие найдено только в одном из трех параметров: уровень шума, разрешающая способность, яркость)
    — более светлая картинка выигрывает у более темной
    — более резкая картинка выигрывает у менее резкой
    — менее шумная выигрывает у более шумной.

    Чтобы найти количественное выражение найденной разницы, надо для лучшей камеры сделать серию снимков с немного отличающимися параметрами (например по экспозиции или по ISO) и, определить, какая из них, после проведения всех манипуляций будет выглядеть идентично проигрышному образцу. Отличие в экспозиции или ISO найденого снимка от исходного и будет разницей.

    Сложность может заключаться, что картинки будут отличаться не по одному, а по двум параметрам. Причем различия эти могут быть скомпенсированы. Например камера А дает более яркую, но чуть более шумную картинку, а камера Б — менее шумную, но более темную. Вполне может оказаться, что после приведения в конвертере яркости светлой картинки к более темной их уровень шума совпадет. Значит, несмотря на различия в картинках, эти камеры имеют одинаковую чувствительность.

    Или вариант посложнее. В современных цифровых камерах присутствует аппаратный шумодав, или, если быть точным, аппаратное решение, снижающее влияние на сигнал шумов, вызванных неидеальностью считывающего и усиливающего тракта. Но суть та же, это уменьшение шумов, сила воздействия которого определяется инженерами производителя. А любая борьба с шумом — это всегда компромиссное решение, между уровнем шумов и уровнем детализации.

    Кроме того, разница в разрешающей способности картинок тоже влияет на эффективную светочувствительность. Простой пример: если мы сделали на две камеры две картинки, имеющие одинаковую попиксельную резкость, одинаковый попиксельный уровень шумов (т.е. картинки одинаковы при рассмотрении в одном масштабе), но у одной из них разрешение 20 Мп, а у другой 10 Мп, то понятно, что первая камера снимает на 1 ступень лучше. И в этом можно наглядно убедиться, потому что после ресайза картинки с 20 до 10 Мп уровень шумов уменьшится ровно на 1 ступень в результате усреднения.

    Вот поэтому я и говорю, что не имеет смысла сравнивать один параметр — шум. Он никак не характеризует камеру. Надо измерять все параметры в связке, а потом интерпретировать полученные результаты. Это, пожалуй, максимум, который можно реализовать в домашних условиях.

    Mr D 02-02-2012 12:14

    Не забудьте еще откидной экранчик в сторону откинуть (у кого есть), даёт очень заметный добавочный тепловой шум на матрице.

    Читать:

    Как отключить обновления на ноутбуке леново