Introdução ao Aprendizado de Máquina Quântico

Visão geral e motivação

Antes de começar, por favor preencha esta pesquisa pré-curso, que é importante para nos ajudar a aprimorar nosso conteúdo e a experiência dos usuários.

Bem-vindo ao aprendizado de máquina quântico!

O vídeo abaixo oferece uma breve introdução que é complementada pelo texto a seguir.

Para recapitular e complementar rapidamente o vídeo:

• Já vimos um problema ser resolvido pela primeira vez num computador quântico e, em seguida, pesquisadores encontraram uma forma de resolvê-lo num supercomputador clássico. Esse ciclo de computação clássica e quântica se desafiando mutuamente até os limites provavelmente vai continuar por alguns anos.
• Existem problemas específicos nos quais a computação quântica pode ter uma vantagem comprovável sobre a computação clássica, dado o progresso em áreas como a redução de erros e o número de qubits disponíveis. Mas este ainda é um tempo de exploração, buscando conjuntos de dados adequados para o quantum e mapas de características quânticos úteis.
• O aprendizado de máquina quântico (QML) é uma das muitas áreas empolgantes em que a computação quântica pode ampliar ou complementar os fluxos de trabalho clássicos existentes.

O aprendizado de máquina (ML) aplica algoritmos a conjuntos de dados, e o QML pode plausivamente incluir a mecânica quântica tanto nos dados quanto no lado algorítmico, ou em ambos. Todas essas possibilidades são potencialmente interessantes. Mas nos restringiremos principalmente a discussões sobre algoritmos quânticos aplicados a dados clássicos. Uma razão para isso é que problemas de ML com dados clássicos já são tão bem estudados e amplamente disponíveis. Há amplo interesse em resolver problemas que partem de dados clássicos. Outra razão é a falta de QRAM. Sem a capacidade de armazenar grandes quantidades de dados quânticos em uma escala de tempo relativamente longa, os métodos que partem de dados quânticos ainda estão bastante longe de aplicabilidade na indústria. Também não está claro como "acessar quanticamente" dados clássicos de forma eficiente. Dois tipos de ML de particular interesse são o aprendizado supervisionado, no qual você treina um algoritmo usando um conjunto de dados rotulado, e o aprendizado não supervisionado, no qual o algoritmo tenta aprender sobre uma distribuição a partir de amostras não rotuladas. Um algoritmo não supervisionado pode, por exemplo, aprender como gerar novas amostras da mesma distribuição, ou como agrupar as amostras em grupos com características semelhantes.

A imagem à esquerda mostra duas categorias de dados rotulados como no aprendizado supervisionado. Neste caso, as categorias são linearmente separáveis. A imagem à direita mostra grupos de dados. Numa tarefa de aprendizado não supervisionado, esses dados não estariam inicialmente rotulados e o algoritmo estudaria a distribuição, talvez buscando grupos. Para fins de visualização dos grupos de exemplo que o algoritmo poderia identificar, os pontos de dados foram rotulados. Uma diferença fundamental entre os dois é que o processo de aprendizado supervisionado começa com os dados já rotulados e o processo não supervisionado começa com dados não rotulados, mesmo que os dados sejam rotulados ao final.

Quem tem experiência em aprendizado de máquina já sabe que muitos métodos de solução envolvem o mapeamento de dados em espaços de dimensão mais alta. Isso é especialmente bem explorado no contexto de kernels. Como um breve lembrete, às vezes os dados podem ser separáveis em categorias por uma linha, plano ou hiperplano (vamos frequentemente dizer apenas "hiperplano" por brevidade), no mesmo número de dimensões em que os dados são fornecidos. Isso é mostrado na primeira imagem acima. Em outros casos, os dados podem não ser separáveis por um hiperplano nessas dimensões, como mostrado na segunda imagem. Mas ainda pode haver estrutura nos dados que pode ser explorada num mapeamento para dimensões mais altas, que então deixa os dados separáveis naquele espaço de dimensão mais alta. Isso é ilustrado no mapeamento dos dados 2D com simetria circular no espaço 3D no qual os pontos de dados estão dispostos ao longo de uma superfície paraboloide.

Um objetivo comum no QML é encontrar um mapeamento do conjunto de características de dimensão mais baixa para um espaço de dimensão mais alta, que separe efetivamente nossos pontos de dados para que possamos usar o mapeamento para classificar novos pontos de dados. Mas essa não é uma tarefa fácil, e qualquer discussão sobre a potencial utilidade da computação quântica no aprendizado de máquina deve ser acompanhada das ressalvas adequadas. Em particular, precisamos abordar a nuance na seleção de conjuntos de dados e os desafios para atingir a escala de utilidade. Também precisamos nos afastar da tentativa de superar algoritmos clássicos de ML em dados que já são tratados eficientemente e bem por algoritmos clássicos, e redirecionar a discussão para investigar novos mapas de características que possam ser úteis.

Gerenciando expectativas

Muitos conjuntos de dados usados em aplicações de QML descritos na literatura são "feature engineered", o que significa que um conjunto de dados é selecionado ou gerado especificamente para mostrar um caso de uso restrito no qual a computação quântica é útil. Se isso parece trapaça, então estamos entendendo mal a tarefa em questão. Não é o caso que alguns mapas de características quânticos nos permitem resolver todas ou muitas tarefas de classificação de forma mais eficiente ou escalável do que os algoritmos clássicos de aprendizado de máquina. Em vez disso, alguns mapas de características quânticos (não todos) se comportam de forma diferente dos mapas de características clássicos. A tarefa em questão é então explorar circuitos quânticos no contexto de estruturas de dados complexas. Algumas perguntas específicas a serem respondidas são:

1. Quais circuitos quânticos têm mais probabilidade de se comportar de maneiras novas, em comparação com as alternativas clássicas?
2. Existem problemas do mundo real que envolvem dados com propriedades melhor exploradas usando tais circuitos quânticos novos?
3. Esses circuitos quânticos escalam em computadores quânticos de curto prazo?

Explicação insuficiente

Com frequência se encontra uma explicação simplificada de como a computação quântica pode ser poderosa. Ela vai mais ou menos assim:

Assim como os computadores clássicos usam bits de informação, os computadores quânticos usam qubits. Dado um número de bits, digamos 4, um computador clássico pode assumir qualquer um dos $2^4 = 16$ estados possíveis, enquanto um computador quântico pode existir numa superposição de todos os 16 estados simultaneamente, e operações podem ser realizadas em toda essa superposição. Em alguns casos, isso naturalmente nos permite projetar algoritmos de aprendizado potencialmente interessantes baseados em mapeamentos para espaços de dimensão mais alta.

Essa é uma afirmação verdadeira, mas é inadequada e um pouco enganosa, como vamos explicar. Também se vê a diferença entre coeficientes complexos e reais ser enfatizada, como em:

Um sistema clássico probabilístico no qual um sistema pode ser descrito como tendo certas probabilidades de estar em diferentes estados pode ser descrito da seguinte forma.

$$|s\rangle = a|0000\rangle+b|0001\rangle+c|0010\rangle+... a, b, c \in \reals$$

Num sistema assim, os coeficientes $a$, $b$, $c$, e assim por diante, só podem ser significativos se forem números reais e positivos. Os estados em computadores quânticos são descritos por amplitudes de probabilidade que podem ser números complexos.

$$|\psi \rangle = A|0000\rangle+B|0001\rangle+C|0010\rangle+... A, B, C \in \mathbb{C}$$

As afirmações acima foram feitas com muito cuidado de forma que sejam verdadeiras (muitas afirmações superficialmente semelhantes são incorretas). Mas essas afirmações corretas não são uma explicação do poder da computação quântica no aprendizado de máquina. Por um lado, qualquer aplicação da computação quântica ao aprendizado de máquina envolverá medições e não podemos medir um qubit em múltiplos estados ao mesmo tempo. Podemos preparar um qubit numa superposição como $|\psi\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$, mas uma medição resultará em $|0\rangle$ ou $|1\rangle$. Então, no mínimo, essa história sobre aumento de dimensionalidade é incompleta. Além disso, no contexto de kernels, o aumento de dimensões na computação quântica não pode ser uma condição suficiente para poder computacional sobre alternativas clássicas, já que kernels Gaussianos têm dimensão infinita. Há sutilezas aí, pois mapas de características Gaussianos são usados apenas em conjunto com o "truque do kernel" que evita a necessidade de calcular um vetor mapeado de dimensão infinita. Mas o ponto permanece:

A alta dimensionalidade de estados quânticos entrelaçados não é paralelismo exponencial, e não é uma condição suficiente para maior poder no aprendizado de máquina.

Nas lições que se seguem, apresentamos fluxos de trabalho para incorporar circuitos quânticos em tarefas de aprendizado de máquina, e fazemos isso com o propósito explícito de facilitar a exploração do poder da computação quântica. Nenhum mapa de características ou algoritmo neste curso é apresentado como um caminho rápido para melhores resultados de aprendizado de máquina para problemas gerais, porque nenhum mapa de características ou algoritmo desse tipo existe. Em vez disso, apresentamos uma ampla variedade de ferramentas quânticas a serem usadas na exploração da computação quântica útil.

Desquantização

Desquantização refere-se à substituição de um dado algoritmo quântico por um clássico que funciona de forma semelhante a um algoritmo quântico para um conjunto específico de tarefas, tipicamente incluindo escalabilidade. Por algumas definições, o algoritmo clássico deve funcionar apenas polinomialmente mais devagar do que o algoritmo quântico.

Vários algoritmos de aprendizado de máquina quântico (QML) que inicialmente se pensava fornecer acelerações significativas sobre algoritmos clássicos foram desquantizados nos últimos anos. Esse processo de desquantização levou a insights importantes sobre as potenciais vantagens e limitações das abordagens quânticas para o aprendizado de máquina.

Um dos resultados de desquantização mais notáveis veio do trabalho de Ewin Tang sobre sistemas de recomendação. Tang descobriu um algoritmo clássico que poderia realizar tarefas de recomendação em velocidades anteriormente consideradas alcançáveis apenas por computadores quânticos. Essa descoberta desafiou a suposição de que algoritmos quânticos tinham uma vantagem exponencial para esse problema. Trabalhos mais recentes de Shin et al. focaram na identificação de condições sobre a desquantizabilidade da classe de funções de um modelo de aprendizado de máquina quântico variacional.

Uma abordagem comum para a desquantização (embora não seja o único truque) é considerar o overhead de carregamento de dados. Ou seja, qualquer algoritmo quântico aplicado a dados clássicos terá uma etapa na qual os dados clássicos são codificados no computador quântico. Se um algoritmo quântico pressupõe um ponto de partida no qual os dados quânticos já estão disponíveis, então efetivamente se esconde o tempo necessário para a codificação. Há contextos nos quais pressupor dados quânticos pode ser razoável, mas muitas aplicações de interesse partirão de dados clássicos. Alguns casos de desquantização mostraram que quando esse tempo de codificação é incluído, e quando o carregamento de dados clássicos pode ser realizado com eficiência, o algoritmo quântico não mais supera seu equivalente clássico.

Mesmo que um algoritmo não possa ser desquantizado, isso não significa que ele seja mais eficiente ou escalável do que todos os algoritmos clássicos. Como um exemplo extremo e artificial: imagine um algoritmo para selecionar os j maiores elementos de um conjunto de tamanho k. Poderia-se escrever um algoritmo quântico que usa o algoritmo de Shor para fatorar cada um dos k elementos em fatores primos, e então determinar os maiores elementos usando os fatores primos. Tal algoritmo provavelmente não pode ser desquantizado, mas é drasticamente menos eficiente do que algoritmos clássicos para realizar a mesma seleção dos maiores elementos (embora não a parte desnecessária de fatoração).

Prova de existência

Em 2021, pesquisadores do IBM Quantum® Yunchao Liu, Srinivasan Arunachalam e Kristan Temme publicaram um artigo na Nature, A rigorous and robust quantum speed-up in supervised machine learning. Coerente com as ressalvas acima, um problema de classificação foi cuidadosamente escolhido para esse trabalho que é (1) classicamente difícil e (2) adequado para algoritmos quânticos mostrarem uma aceleração.

O artigo aborda a classificação de dados com base em logaritmos discretos. Para citar o artigo, "Para um grande número primo $p$ e um gerador $g$ de $\mathbb{Z}^*_p = {1, 2, . . . , p − 1}$, é uma conjetura amplamente aceita que nenhum algoritmo clássico pode calcular $\text{log}_g(x)$ na entrada $x \in \mathbb{Z}^*_p$, em tempo polinomial em $n = \lceil{\text{log}_2(p)}\rceil$, o número de bits necessários para representar $p$." Em contraste, o algoritmo de Shor é conhecido por resolver o problema do logaritmo discreto em tempo polinomial. Essa escolha de problemas satisfaz simultaneamente os critérios acima: dificuldade clássica (improvável de ser desquantizado) e adequação conhecida para algoritmos quânticos.

Por meio dessa escolha criteriosa do problema de classificação, os autores conseguiram mostrar uma aceleração exponencial usando métodos de kernel quântico (esboçados brevemente abaixo e discutidos em lições posteriores) que é tanto de ponta a ponta quanto robusta. Aqui, "de ponta a ponta" refere-se às suposições sobre começar com dados clássicos; os autores neste caso incluem o tempo para codificação de dados. Aqui, "robusto" refere-se ao fato de que os dados a serem classificados são separados por uma ampla margem usando o algoritmo quântico, de modo que o sucesso da classificação é robusto a considerações do mundo real como erros de amostragem finita.

Tudo isso é para dizer que existem problemas nos quais kernels quânticos podem gerar uma aceleração exponencial. Mas o estado atual da ciência é que tais problemas são selecionados com base em observações ou justificativas teóricas de que deveriam ser adequados para algoritmos quânticos. Não é realista esperar uma aceleração quântica para tarefas de aprendizado de máquina que computadores clássicos já realizam muito bem.

Identificar esses casos ideais para a exploração da utilidade quântica é uma enorme responsabilidade para quem estuda este curso. E não é uma tarefa que pode ser concluída num curso como este. Essa exploração é uma tarefa para toda a IBM Quantum Network, composta por pesquisadores como você. Este curso vai demonstrar fluxos de trabalho de QML e estratégias de codificação para que você possa começar a explorar a utilidade quântica na sua área de especialização.

Esperamos que esta introdução tenha deixado algumas coisas claras sobre o aprendizado de máquina quântico:

1. Algoritmos quânticos podem oferecer uma aceleração exponencial sobre algoritmos clássicos para problemas muito específicos que são classicamente difíceis e bem adequados para algoritmos quânticos.
2. A alta dimensionalidade de estados entrelaçados na computação quântica importa, mas não é suficiente simplesmente para ganhar vantagem sobre algoritmos clássicos.
3. Encontrar problemas bem adequados para algoritmos quânticos é uma tarefa extremamente difícil, e uma que vai recair em grande parte sobre quem estuda este curso.

Perguntas de verificação

O que torna os estados quânticos diferentes dos estados clássicos?

Resposta:

Muita coisa. Notavelmente: coeficientes complexos e superposição com uma única cópia. Há muitas outras diferenças que serão discutidas em lições futuras, incluindo entrelaçamento e interferência.

Verdadeiro ou Falso? Estados quânticos altamente entrelaçados nos permitem resolver a maioria dos problemas de aprendizado de máquina de forma mais eficiente num computador quântico.

Resposta:

Falso. A maioria dos problemas de aprendizado de máquina é resolvida de forma muito eficiente por algoritmos clássicos e é improvável que algoritmos quânticos ofereçam qualquer aceleração substancial. O objetivo no QML é encontrar conjuntos de dados com características bem descritas por estados quânticos e/ou encontrar mapeamentos de características de dados que otimizem a precisão dos modelos.

Objetivos de aprendizado do curso

Ao completar este curso, você pode esperar desenvolver as seguintes habilidades e competências centrais. Os estudantes serão capazes de:

1. Explicar o que é QML e onde o quantum se conecta ao aprendizado de máquina clássico.

2. Aplicar vocabulário quântico e termos-chave aos fluxos de trabalho de ML.

3. Identificar os componentes-chave de um fluxo de trabalho de QML (vários tipos).

4. Identificar diferentes tipos de QML e distinguir entre eles.

5. Implementar métodos de kernel quântico e classificadores quânticos variacionais usando primitivas do Qiskit Runtime e seguindo os padrões Qiskit.

6. Identificar onde o QML é mais promissor e onde não é.

7. Adaptar um problema de exemplo ao seu próprio conjunto de dados.

8. Estar ciente de problemas no QML como tempo de treinamento, ruído e erro acumulado em leituras de múltiplos estados.

9. Fazer recomendações sobre onde o QML pode beneficiar sua organização.

Estrutura do curso

Este curso é composto por várias lições. Cada lição tem diversas perguntas de verificação ao longo do texto, para que você possa praticar novas habilidades ou verificar sua compreensão à medida que avança. Elas não são obrigatórias.

Ao final do curso, há um quiz de 20 itens. Você precisa pontuar pelo menos 70% neste quiz para obter seu badge de Aprendizado de Máquina Quântico, via Credly. Se você pontuar pelo menos 70%, seu badge será enviado automaticamente por e-mail para você, logo depois. Você só pode enviar o quiz duas vezes. Após a primeira submissão, você terá a oportunidade de fazer uma segunda tentativa nas perguntas que errou. Após a segunda submissão, sua pontuação é final. Veja o quiz para mais detalhes.

A estrutura do curso é a seguinte:

• Lição 1: Introdução e visão geral
• Lição 2: Revisão de aprendizado de máquina
• Lição 3: Codificação de dados
• Lição 4: Métodos de kernel quântico e máquinas de vetores de suporte
• Lição 5: Classificadores quânticos variacionais / redes neurais
• Exame para badge

Execute seu primeiro código QML

Geralmente é útil ver onde vamos chegar, antes de decompor tudo em partes e mergulhar no contexto. As células de código abaixo executam uma instância simples de um método de kernel quântico. Especificamente, um único elemento da matriz de kernel é calculado. Usuários que não conhecem métodos de kernel ou kernels quânticos não devem se intimidar com isso; várias lições neste curso serão dedicadas a dissecar exatamente o que está sendo feito nessas células.

Com este código introduzimos simultaneamente os padrões Qiskit: um framework para abordar a computação quântica em escala de utilidade. Esse framework consiste em quatro etapas que são bastante gerais e podem ser aplicadas à maioria dos problemas (embora em alguns fluxos de trabalho, certas etapas possam ser iteradas várias vezes).

Padrões Qiskit:

• Etapa 1: Mapear entradas clássicas para um problema quântico
• Etapa 2: Otimizar o problema para execução quântica
• Etapa 3: Executar usando primitivas do Qiskit Runtime
• Etapa 4: Analisar / pós-processamento

Nas células abaixo, oferecemos apenas explicações superficiais das várias etapas, apenas o suficiente para você encontrar a lição apropriada para aprender mais.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy pandas qiskit

# Import some qiskit packages required for setting up our quantum circuits.
from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit
from qiskit.circuit.library import unitary_overlap

# Import StatevectorSampler as our sampler.
from qiskit.primitives import StatevectorSampler

# Step 1: Map classical inputs to a quantum problem:

# Start by getting some appropriate data. The data imported below consist of 128 rows or data points.
# Each row has 14 columns that correspond to data features, and a 15th column with a label (+/-1).
!wget https://raw.githubusercontent.com/qiskit-community/prototype-quantum-kernel-training/main/data/dataset_graph7.csv

# Import some required packages, and write a function to pull some training data out of the csv file you got above.
import pandas as pd
import numpy as np

def get_training_data():
    """Read the training data."""
    df = pd.read_csv("dataset_graph7.csv", sep=",", header=None)
    training_data = df.values[:20, :]
    ind = np.argsort(training_data[:, -1])
    X_train = training_data[ind][:, :-1]

    return X_train

# Prepare training data
X_train = get_training_data()

# Empty kernel matrix
num_samples = np.shape(X_train)[0]

# Prepare feature map for computing overlap between two data points.
# This could be pre-built feature maps like ZZFeatureMap, or a custom quantum circuit, as shown here.
num_features = np.shape(X_train)[1]
num_qubits = int(num_features / 2)
entangler_map = [[0, 2], [3, 4], [2, 5], [1, 4], [2, 3], [4, 6]]
fm = QuantumCircuit(num_qubits)
training_param = Parameter("θ")
feature_params = ParameterVector("x", num_qubits * 2)
fm.ry(training_param, fm.qubits)
for cz in entangler_map:
    fm.cz(cz[0], cz[1])
for i in range(num_qubits):
    fm.rz(-2 * feature_params[2 * i + 1], i)
    fm.rx(-2 * feature_params[2 * i], i)

# Pick two data points, here 14 and 19, and assign the features to the circuits as parameters.
x1 = 14
x2 = 19
unitary1 = fm.assign_parameters(list(X_train[x1]) + [np.pi / 2])
unitary2 = fm.assign_parameters(list(X_train[x2]) + [np.pi / 2])

# Create the overlap circuit
overlap_circ = unitary_overlap(unitary1, unitary2)
overlap_circ.measure_all()
overlap_circ.draw("mpl", scale=0.6, style="iqp")

# Step 2: Optimize problem for quantum execution

# Use Qiskit Runtime service to get the least busy backend for running on real quantum computers.
# from qiskit_ibm_runtime import QiskitRuntimeService

# service = QiskitRuntimeService(channel="ibm_quantum")
# backend = service.least_busy(
#    operational=True, simulator=False, min_num_qubits=overlap_circ.num_qubits
# )

# Transpile the circuits optimally for the chosen backend using a pass manager.
# from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
# pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
# overlap_ibm = pm.run(overlap_circ)

# Step 3: Execute using Qiskit Runtime Primitives

# Specify the number of shots to use.
num_shots = 10_000

## Evaluate the problem using statevector-based primitives from Qiskit
sampler = StatevectorSampler()
counts = (
    sampler.run([overlap_circ], shots=num_shots).result()[0].data.meas.get_int_counts()
)

# Step 4: Analyze and post-processing

# Find the probability of 0.
counts.get(0, 0.0) / num_shots

--2025-05-09 10:04:28--  https://raw.githubusercontent.com/qiskit-community/prototype-quantum-kernel-training/main/data/dataset_graph7.csv
Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.109.133, 185.199.108.133, ...
Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 49405 (48K) [text/plain]
Saving to: ‘dataset_graph7.csv.2’

dataset_graph7.csv. 100%[===================>]  48.25K  --.-KB/s    in 0.03s   

2025-05-09 10:04:29 (1.37 MB/s) - ‘dataset_graph7.csv.2’ saved [49405/49405]

0.8199

Embora você não precise entender todas as etapas acima, devemos tentar entender a saída, para saber por que estamos fazendo isso. Muitos processos em aprendizado de máquina usam produtos internos como parte da classificação binária (entre outras coisas). A mecânica quântica tem uma conexão óbvia com isso, já que as probabilidades de medir vários estados $|\phi_i\rangle$ são dadas pelo produto interno com um estado inicial $|\psi\rangle$ através do produto interno: $P_i = |\langle\phi_i|\psi\rangle|^2$. Então o que fizemos acima foi criar um circuito quântico que contém as características dos nossos dois pontos de dados, e os mapeia para o espaço de um vetor quântico, depois estima o produto interno nesse espaço fazendo medições. Isso é um exemplo de estimação de kernel quântico. Note que implementamos esse processo apenas para dois dos pontos de dados (o 14º e o 19º). Se fizéssemos isso para todos os pares possíveis, poderíamos pegar a saída (neste caso o número 0,821...) e popular uma matriz de resultados descrevendo a sobreposição entre todos os pontos do conjunto de dados de treinamento. Essa é a "matriz de kernel".

Verifique seu entendimento

Leia a pergunta abaixo, pense na sua resposta, depois clique no triângulo para revelar a solução.

No processo acima, calculamos uma entrada da matriz de kernel para os 14º e 19º pontos de dados. Que valor devemos obter se usarmos o mesmo ponto de dados duas vezes, aqui (como o 14º e o 14º novamente)? Em outras palavras, quais deveriam ser as entradas diagonais na matriz de kernel? Responda esta pergunta na ausência de ruído, mas note que desvios da sua resposta são possíveis na presença de ruído.

Resposta:

As diagonais deveriam ser 1,0. Esse processo deve estar calculando o produto interno normalizado de um vetor com ele mesmo, que deve sempre ser um.