KVANTNA RAČUNALA - SLOŽENI PRIMJER

Kao složeni primjer korištenja kvantnih računala pomoću Microsoftovog alata QDK prikazat ćemo primjer s područja strojnog učenja. Ovo je vrlo složen primjer koji uključuje korištenje dodatnih Microsoftovih modela za upoznavanje i procjenu kvalitete vina. Za pripremu modela u ovom slučaju se osim programskoga kôda u Q# i C# koristi i Python.

Projekt se sastoji od triju dijelova pisanih u različitim programskim jezicima već prema tome za što se koristi pojedini dio. Programski kôd u jeziku Q# na početku sadrži nekoliko jednostavnijih funkcija kao što su SampleSingleParameter ili SampleParametersForSequence. Ključna struktura za provođenje klasifikacije podataka ClassifierStructure koristi operatore kakvi se nalaze u okviru načina mjerenja rezultata pod nazivom Pauli. Više o spomenutoj temi može se pronaći na ovoj web-adresi.

Na kraju, u okviru dijela kôda napisanog u Q# nalaze se dvije glavne funkcije za treniranje i provjeru modela: TrainWineModel i ValidateWineModel.

namespace Microsoft.Quantum.Samples {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Arrays;
    open Microsoft.Quantum.MachineLearning;
    open Microsoft.Quantum.MachineLearning.Datasets as Datasets;
    open Microsoft.Quantum.Math;

    function DefaultSchedule(samples : LabeledSample[]) : SamplingSchedule {
        return SamplingSchedule([
            0..Length(samples) - 1
        ]);
    }

    function ClassifierStructure() : ControlledRotation[] {
        return CombinedStructure([
            LocalRotationsLayer(4, PauliZ),
            LocalRotationsLayer(4, PauliX),
            CyclicEntanglingLayer(4, PauliX, 1),
            PartialRotationsLayer([3], PauliX)
        ]);
    }

    operation SampleSingleParameter() : Double {
        return PI() * (RandomReal(16) - 1.0);
    }

    operation SampleParametersForSequence(structure : ControlledRotation[]) 
              : Double[] {
        return ForEach(SampleSingleParameter, ConstantArray(Length(structure), ()));
    }

    operation SampleInitialParameters(nInitialParameterSets : Int, structure 
              : ControlledRotation[]) : Double[][] {
        return ForEach(SampleParametersForSequence, 
               ConstantArray(nInitialParameterSets, structure));
    }

    operation TrainWineModel() : (Double[], Double) {
        // Get the first 143 samples to use as training data.
        let samples = (Datasets.WineData())[...142];
        let structure = ClassifierStructure();
        // Sample a random set of parameters.
        let initialParameters = SampleInitialParameters(16, structure);

        Message("Ready to train.");
        let (optimizedModel, nMisses) = TrainSequentialClassifier(
            Mapped(
                SequentialModel(structure, _, 0.0),
                initialParameters
            ),
            samples,
            DefaultTrainingOptions()
                w/ LearningRate <- 0.4
                w/ MinibatchSize <- 2
                w/ Tolerance <- 0.01
                w/ NMeasurements <- 10000
                w/ MaxEpochs <- 16
                w/ VerboseMessage <- Message,
            DefaultSchedule(samples),
            DefaultSchedule(samples)
        );
        Message($"Training complete, found optimal parameters: 
               {optimizedModel::Parameters}"
);
        return (optimizedModel::Parameters, optimizedModel::Bias);
    }

    operation ValidateWineModel(
        parameters : Double[],
        bias : Double
    ) : Int {
        // Get the remaining samples to use as validation data.
        let samples = (Datasets.WineData())[143...];
        let tolerance = 0.005;
        let nMeasurements = 10000;
        let results = ValidateSequentialClassifier(
            SequentialModel(ClassifierStructure(), parameters, bias),
            samples,
            tolerance,
            nMeasurements,
            DefaultSchedule(samples)
        );
        return results::NMisclassifications;
    }

}

Dio programskoga kôda napisan u programskom jeziku C# zadužen je za upravljanje izvođenjem cijeloga projekta što uključuje i ranije spomenute dijelove napisane u Q#. Kao dio procjene kvalitete modela na kraju se ispisuje broj neuspješno provedenih pokušaja klasifikacije.

Budući da (ovisno o korištenom računalu) izvođenje može potrajati neko vrijeme, klasa SimulatorExtensions neprekidno ispisuje poruke o trenutnoj operaciji ispred koje se nalazi i trenutno vrijeme. Tako se izvođenje modela može pratiti prema vremenu te po vrsti operacije.

using Microsoft.Quantum.Simulation.Core;
using
 Microsoft.Quantum.Simulation.Simulators;
using
 System;
using
 System.IO;
using
 System.Linq;
using
 System.Text.Json;
using
 System.Runtime.InteropServices;
using
 System.Collections.Generic;
using
 System.Threading.Tasks;
using
 System.Diagnostics;
using
 static System.Math;

namespace Microsoft.Quantum.Samples
{
    using Microsoft.Quantum.MachineLearning;
    class Program
    {
        static async Task Main(string[] args)
        {

            // Next, we initialize a full state-vector simulator as our target machine.
            using var targetMachine = new QuantumSimulator().WithTimestamps();

            // Once we initialized our target machine,
            // we can then use that target machine to train a QCC classifier.
            var (optimizedParametersoptimizedBias
                = 
await TrainWineModel.Run(targetMachine);  

            // After training, we can use the validation data to test 
            // the accuracy of our new classifier.

            var testMisses = await ValidateWineModel.Run(
                targetMachine,
                optimizedParameters,
                optimizedBias
            );

            System.Console.WriteLine($"Observed {testMisses} misclassifications.");
        }
    }

    public static class SimulatorExtensions
    {
        public static QuantumSimulator WithTimestamps(this QuantumSimulator sim)
        {

            var stopwatch = new Stopwatch();
            stopwatch.Start();
            var last = stopwatch.Elapsed;
            sim.DisableLogToConsole();
            sim.OnLog += (message) =>
            {

                var now = stopwatch.Elapsed;
                Console.WriteLine($"[{now} +{now - last}] {message}");
                last = now;
            };

            return sim;
        }
    }
}

Za pristup odgovarajućim Microsoftovim modelima za strojno učenje, optimiziranim za korištenje u kombinaciji s alatom MQDK, koristi se sljedeći dio Python kôda:

import qsharp
qsharp.packages.add("Microsoft.Quantum.MachineLearning::0.11.2004.2825")
qsharp.reload()

from Microsoft.Quantum.Samples import TrainWineModel, ValidateWineModel

if __name__ == "__main__":
    (parameters, bias) = TrainWineModel.simulate()

    miss_rate = ValidateWineModel.simulate(
        parameters=parameters, bias=bias
    )

    print(f"Miss rate: {miss_rate:0.2%}")

Slijedi primjer izvođenja s prikazom podataka na samom početku i na kraju izvođenja modela. Na računalu na kojem je pripreman ovaj tekst čitav postupak potrajao je skoro pola sata, tako da se treba naoružati odgovarajućim strpljenjem. Na samom kraju prikazuju se optimalne vrijednosti modela.

Početak izvođenja modela

Slika 1. Početak izvođenja modela — prvo se provodi njegovo treniranje.

 

[00:00:00.3006986 +00:00:00.3006968] Ready to train.
[00:00:00.3356587 +00:00:00.0349601]   Beginning training at start point #0...
[00:00:00.9230099 +00:00:00.5873512]     Pre-encoding samples...
[00:00:00.9428761 +00:00:00.0198662]     Beginning epoch 1.
[00:00:01.2493187 +00:00:00.3064426]         Beginning minibatch 0 of 26.
[00:00:01.2590523 +00:00:00.0097336]       Estimating gradient at sample 0...
[00:00:01.3373943 +00:00:00.0783420]       Estimating gradient at sample 1...
[00:00:01.4075296 +00:00:00.0701353]             Observed good parameter update... estimating and possibly commiting.
[00:00:01.6869018 +00:00:00.2793722]         Beginning minibatch 1 of 26.
[00:00:01.6870654 +00:00:00.0001636]       Estimating gradient at sample 0...
[00:00:01.7296521 +00:00:00.0425867]       Estimating gradient at sample 1...
[00:00:01.7952022 +00:00:00.0655501]             Observed good parameter update... estimating and possibly commiting.

....

[00:28:32.5480935 +00:00:00.0002094]       Estimating gradient at sample 0...
[00:28:32.6080891 +00:00:00.0599956]             Observed good parameter update... estimating and possibly commiting.
[00:28:33.1371447 +00:00:00.5290556] Training complete, found optimal parameters: [-1,5193446625884046,-2,430577187492097,-1,232298507655304,-1,0808658417512185,
-0,8108852230833453,-1,6012208871418008,-0,40203140621220057,-2,403013470209777,
-0,5913495937299147,-2,031326121457939,-1,0042301101692592,-2,4099796915675853,
-2,3941930806794343]

Observed 8 misclassifications.

Na kraju se prikazuju rezultati koji se dobiju pomoću „istreniranog“ modela.

Slika 2. Na kraju se prikazuju rezultati koji se dobiju pomoću „istreniranog“ modela.

Nadamo se da su vam tekstovi iz ovog serijala bar malo približili način na koji djeluju kvantna računala. Uz pomoć alata MQDK namijenjenoga simulaciji rada kvantnih računala već danas možete upoznati kako se takva računala programiraju.

Kategorija