Classificação básica: Classificar os dados com o QDKBasic classification: Classify data with the QDK

Neste Quickstart, você aprenderá a executar um classificador sequencial quântico escrito na Q# utilização da biblioteca Quantum Machine Learning do QDK.In this Quickstart, you will learn how to run a quantum sequential classifier written in Q# using the Quantum Machine Learning library of the QDK.

Neste guia utilizaremos o conjunto de dados de meia-lua, utilizando uma estrutura de classificador definida em Q# .In this guide we will use the half-moon dataset, using a classifier structure defined in Q#.

Pré-requisitosPrerequisites

Programa de acolhimentoHost program

O seu programa de anfitriões é composto por três partes:Your host program consists of three parts:

  • Carregue o conjunto de dados e escolha um conjunto de parâmetros iniciais para o seu modelo.Load the dataset and choose a set of starting parameters for your model.

  • Executar treino para determinar os parâmetros e o enviesamento do modelo.Run training to determine the parameters and bias of the model.

  • Validar o modelo para determinar a sua precisãoValidate the model to determine its accuracy

    Para executar você é o Q# classificador de Python, guarde o seguinte código como host.py .To run your the Q# classifier from Python, save the following code as host.py. Lembre-se que também precisa do Q# ficheiro que é explicado mais tarde neste Training.qs tutorial.Remember that you also need the Q# file Training.qs that is explained later in this tutorial.

    
    import json
    
    import numpy as np
    import matplotlib.pyplot as plt
    import matplotlib.colors as colors
    import matplotlib.cm as cmx
    plt.style.use('ggplot')
    
    import qsharp
    
    from Microsoft.Quantum.Samples import (
        TrainHalfMoonModel, ValidateHalfMoonModel, ClassifyHalfMoonModel
    )
    
    if __name__ == "__main__":
        with open('data.json') as f:
            data = json.load(f)
        parameter_starting_points = [
            [0.060057, 3.00522,  2.03083,  0.63527,  1.03771, 1.27881, 4.10186,  5.34396],
            [0.586514, 3.371623, 0.860791, 2.92517,  1.14616, 2.99776, 2.26505,  5.62137],
            [1.69704,  1.13912,  2.3595,   4.037552, 1.63698, 1.27549, 0.328671, 0.302282],
            [5.21662,  6.04363,  0.224184, 1.53913,  1.64524, 4.79508, 1.49742,  1.545]
         ]
    
        (parameters, bias) = TrainHalfMoonModel.simulate(
            trainingVectors=data['TrainingData']['Features'],
            trainingLabels=data['TrainingData']['Labels'],
            initialParameters=parameter_starting_points
        )
    
        miss_rate = ValidateHalfMoonModel.simulate(
            validationVectors=data['ValidationData']['Features'],
            validationLabels=data['ValidationData']['Labels'],
            parameters=parameters, bias=bias
        )
    
        print(f"Miss rate: {miss_rate:0.2%}")
    
        # Classify the validation so that we can plot it.
    

    Em seguida, pode executar o programa anfitrião do Python na linha de comandos:You can then run your Python host program from the command line:

    $ python host.py
    Preparing Q# environment...
    [...]
    Observed X.XX% misclassifications.
    

Código # de classificação QQ# classifier code

Agora vamos ver como as operações invocadas pelo programa de acolhimento são definidas em Q# .Now let's see how the operations invoked by the host program are defined in Q#. Guardamos o seguinte código num ficheiro chamado Training.qs .We save the following code in a file named Training.qs.

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

    function WithProductKernel(scale : Double, sample : Double[]) : Double[] {
        return sample + [scale * Fold(TimesD, 1.0, sample)];
    }

    function Preprocessed(samples : Double[][]) : Double[][] {
        let scale = 1.0;

        return Mapped(
            WithProductKernel(scale, _),
            samples
        );
    }

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

    function ClassifierStructure() : ControlledRotation[] {
        return [
            ControlledRotation((0, new Int[0]), PauliX, 4),
            ControlledRotation((0, new Int[0]), PauliZ, 5),
            ControlledRotation((1, new Int[0]), PauliX, 6),
            ControlledRotation((1, new Int[0]), PauliZ, 7),
            ControlledRotation((0, [1]), PauliX, 0),
            ControlledRotation((1, [0]), PauliX, 1),
            ControlledRotation((1, new Int[0]), PauliZ, 2),
            ControlledRotation((1, new Int[0]), PauliX, 3)
        ];
    }

    operation TrainHalfMoonModel(
        trainingVectors : Double[][],
        trainingLabels : Int[],
        initialParameters : Double[][]
    ) : (Double[], Double) {
        let samples = Mapped(
            LabeledSample,
            Zip(Preprocessed(trainingVectors), trainingLabels)
        );
        Message("Ready to train.");
        let (optimizedModel, nMisses) = TrainSequentialClassifier(
            Mapped(
                SequentialModel(ClassifierStructure(), _, 0.0),
                initialParameters
            ),
            samples,
            DefaultTrainingOptions()
                w/ LearningRate <- 0.1
                w/ MinibatchSize <- 15
                w/ Tolerance <- 0.005
                w/ NMeasurements <- 10000
                w/ MaxEpochs <- 16
                w/ VerboseMessage <- Message,
            DefaultSchedule(trainingVectors),
            DefaultSchedule(trainingVectors)
        );
        Message($"Training complete, found optimal parameters: {optimizedModel::Parameters}");
        return (optimizedModel::Parameters, optimizedModel::Bias);
    }

    operation ValidateHalfMoonModel(
        validationVectors : Double[][],
        validationLabels : Int[],
        parameters : Double[],
        bias : Double
    ) : Double {
        let samples = Mapped(
            LabeledSample,
            Zip(Preprocessed(validationVectors), validationLabels)
        );
        let tolerance = 0.005;
        let nMeasurements = 10000;
        let results = ValidateSequentialClassifier(
            SequentialModel(ClassifierStructure(), parameters, bias),
            samples,
            tolerance,
            nMeasurements,
            DefaultSchedule(validationVectors)
        );
        return IntAsDouble(results::NMisclassifications) / IntAsDouble(Length(samples));
    }

    operation ClassifyHalfMoonModel(
        samples : Double[][],
        parameters : Double[],
        bias : Double,
        tolerance  : Double,
        nMeasurements : Int
    )
    : Int[] {
        let model = Default<SequentialModel>()
            w/ Structure <- ClassifierStructure()
            w/ Parameters <- parameters
            w/ Bias <- bias;
        let features = Preprocessed(samples);
        let probabilities = EstimateClassificationProbabilities(
            tolerance, model,
            features, nMeasurements
        );
        return InferredLabels(model::Bias, probabilities);
    }

}

As funções e operações mais importantes definidas no código acima são:The most important functions and operations defined in the code above are:

  • ClassifierStructure() : ControlledRotation[] : nesta função definimos a estrutura do nosso modelo de circuito adicionando as camadas dos portões controlados que consideramos.ClassifierStructure() : ControlledRotation[] : in this function we set the structure of our circuit model by adding the layers of the controlled gates we consider. Este passo é análogo à declaração de camadas de neurónios num modelo sequencial de aprendizagem profunda.This step is analogous to the declaration of layers of neurons in a sequential deep learning model.
  • TrainHalfMoonModel() : (Double[], Double) : esta operação é a parte central do código e define a formação.TrainHalfMoonModel() : (Double[], Double) : this operation is the core part of the code and defines the training. Aqui carregamos as amostras do conjunto de dados incluído na biblioteca, definimos os hipermetrões e os parâmetros iniciais para o treino e começamos a formação chamando a operação TrainSequentialClassifier incluída na biblioteca.Here we load the samples from the dataset included in the library, we set the hyper parameters and the initial parameters for the training and we start the training by calling the operation TrainSequentialClassifier included in the library. Produz os parâmetros e o enviesamento que determina o classificador.It outputs the parameters and the bias that determine the classifier.
  • ValidateHalfMoonModel(parameters : Double[], bias : Double) : Int : esta operação define o processo de validação para avaliar o modelo.ValidateHalfMoonModel(parameters : Double[], bias : Double) : Int : this operation defines the validation process to evaluate the model. Aqui carregamos as amostras para validação, o número de medições por amostra e a tolerância.Here we load the samples for validation, the number of measurements per sample and the tolerance. Produz o número de classificações erradas no lote escolhido de amostras para validação.It outputs the number of misclassifications on the chosen batch of samples for validation.

Passos seguintesNext steps

Primeiro, podes jogar com o código e tentar alterar alguns parâmetros para ver como isso afeta o treino.First, you can play with the code and try to change some parameters to see how it affects the training. Em seguida, no próximo tutorial, desenhe o seu próprio classificador,aprenderá a definir a estrutura do classificador.Then, in the next tutorial, Design your own classifier, you will learn how to define the structure of the classifier.