O modelo

Foi decidido que iriamos implementar um modelo que seja mais leve em termos de sua arquitetura já que o foco do projeto era explorar algorítimos quânticos e não a performance do modelo. Por isso, foi escolhido o modelo AlexNet, que é um modelo que possui uma arquitetura mais simples e que é mais leve em termos de processamento.

Sobre o modelo

A AlexNet é uma arquitetura de CNN que se tornou amplamente conhecida por seu desempenho impressionante na competição ImageNet Large Scale Visual Recognition Challenge de 2012. A ImageNet é um conjunto de dados que contém milhões de imagens em diversas categorias, e a competição desafiou os participantes a desenvolver algoritmos capazes de reconhecer objetos e categorias nas imagens com alta precisão.

AlexNet

Implementação

A implementação do modelo foi feita utilizando a biblioteca PyTorch, que é uma biblioteca de aprendizado de máquina de código aberto para Python, e que possui uma boaa integração com o Qiskit.

Podemos observar a implementação do modelo abaixo:

class AlexNetQNN(nn.Module):
    def __init__(self, output_dim, backend=None, is_qnn=True):
        super().__init__()
 
        self.features = nn.Sequential(
            nn.Conv2d(
                3, 64, 3, 2, 1
            ),  # in_channels, out_channels, kernel_size, stride, padding
            nn.MaxPool2d(2),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 192, 3, padding=1),
            nn.MaxPool2d(2),
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 384, 3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 256, 3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, 3, padding=1),
            nn.MaxPool2d(2),
            nn.ReLU(inplace=True),
        )
 
        self.classifier = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(256 * 16 * 16, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096, output_dim),
        )
 
        self.is_qnn = is_qnn
        self.hybrid = TorchConnector(create_qnn(output_dim, backend))
 
    def forward(self, x):
        x = self.features(x)
        h = x.view(x.shape[0], -1)
        x = self.classifier(h)
        if self.is_qnn:
            x = self.hybrid(x)
        return x, h

Ressaltando apenas a parte que é referente ao modelo quântico:

self.is_qnn = is_qnn
self.hybrid = TorchConnector(create_qnn(output_dim, backend))

A camada self.hybrid é responsável por fazer a conexão entre o modelo clássico e o modelo quântico, onde graças ao método TorchConnector é possível fazer a conversão do modelo clássico para o modelo quântico. Onde antigamente era necessário fazer a construção da camada quântica manualmente, agora é possível fazer a conversão de forma automatizada.

Os dados O circuito quântico