Exercício – Criar uma rede neural para classificar rochas espaciais

  • 10 minutos

Vamos criar uma rede neural (ou rede de aprendizado profundo) para aprender as associações entre os recursos e cada tipo de rocha. Os recursos podem incluir itens como curvas, bordas e textura.

Neurônios e redes com fio

As redes neurais processam informações de modo semelhante a como nossos cérebros funcionam. Nosso cérebro consiste em neurônios ou células nervosas que transmitem e processam informações dos nossos sentidos. Muitas células nervosas são dispostas como uma rede de nervos no cérebro. Os nervos transmitem impulsos elétricos de um neurônio para o próximo na rede.

As redes neurais têm milhões de neurônios e nervos. Para criar uma rede neural funcional, nós conectamos os neurônios e os nervos em duas etapas:

  • Etapa A: criar todos os neurônios.
  • Etapa B: conectar os neurônios de maneira apropriada. (Há milhares de maneiras de conectar neurônios.)

Em nosso modelo, vamos coletar as características de uma rocha de uma imagem e os armazenar como uma sequência linear de parâmetros. Esta etapa cria apenas um neurônio. Cada nova imagem analisada é outro neurônio. Fornecemos os dados de treinamento do nosso computador para criar todos os neurônios.

Em seguida, vamos dizer ao computador para combinar as sequências em uma matriz. A matriz representa o melhor padrão que temos para descrever as características dos tipos de rocha espacial. Esta matriz é uma rede com fio.

Vamos treinar nosso modelo para prever o tipo de rocha. Vamos comparar as características da rocha em uma nova imagem com o padrão de matriz. Cada vez que executamos o modelo, a matriz cresce e a precisão da previsão melhora. Nossa meta é testar o modelo e atingir uma precisão de previsão perto de 100%.

Verificar o ambiente de trabalho

Para adicionar um código ao modelo de IA, precisamos verificar se o seu ambiente de desenvolvimento ainda está ativo.

Se você fechou o prompt do Anaconda ou Visual Studio Code, precisa reiniciá-los. Você precisará configurar seu ambiente para continuar a trabalhar em seu modelo de IA.

Se o prompt do Anaconda ainda estiver aberto em seu trabalho para o módulo anterior e você não tiver fechado o Visual Studio Code, continue na seção Criar uma rede neural.

Verificar seu ambiente do Anaconda (myenv)

Se você fechou o prompt do Anaconda depois de concluir os exercícios no módulo anterior, siga estas etapas para reiniciar o seu ambiente.

  1. Inicie o aplicativo de prompt do Anaconda (ou terminal no Mac).

  2. No prompt do Anaconda, digite o seguinte comando para ativar o seu ambiente:

    conda activate myenv

  3. Use o seguinte comando para verificar a instalação do pacote torchvision:

    conda install -c pytorch torchvision

    O sistema deve relatar que todos os pacotes solicitados já estão instalados. Você pode ignorar avisos sobre a versão do Anaconda (Conda).

Reiniciar o Visual Studio e o kernel do Python

Se você atualizou o ambiente do Anaconda seguindo as etapas anteriores ou fechou o Visual Studio Code depois de concluir os exercícios no módulo anterior, será necessário reiniciar o aplicativo e o kernel do Python myenv.

  1. Reinicie o Visual Studio Code.

  2. Abra o arquivo do Jupyter Notebook que você criou anteriormente.

    No módulo anterior, demos ao nosso arquivo do Jupyter Notebook o nome ClassifySpaceRockProgram.ipynb.

  3. Inicie o kernel myenv do Jupyter Python. Nos cantos superior direito e inferior esquerdo do Visual Studio, altere para o ambiente Anaconda ('myenv') que você criou antes.

Execute novamente as células no arquivo do Jupyter Notebook

Se você atualizou seu ambiente do Anaconda ou reiniciou o Visual Studio Code, precisa executar as células existentes no arquivo do Jupyter Notebook para adicionar células de código.

  1. Para executar outra vez as células no arquivo do Jupyter Notebook, inicie pela primeira célula no arquivo do Notebook.

  2. Execute cada célula no Notebook em ordem, da primeira célula no arquivo até a última.

  3. Se não houver erros, continue na próxima seção, Criar uma rede neural.

Solucionar problemas de erros de ambiente

Aqui estão algumas dicas para ajudar a solucionar problemas de erros no processo de instalação:

  • Se você receber erros ao executar células existentes no arquivo de Jupyter Notebook, verifique se você seguiu todas as etapas nesta seção:

    1. Reinicie o ambiente do Anaconda. Ative myenv. Verifique a instalação do torchvision.
    2. Reinicie o Visual Studio Code. Reinicie o kernel do Jupyter myenv Python.
    3. Execute as células existentes no arquivo Jupyter Notebook, da primeira célula até a última.

  • Se você receber um erro sobre um comando ou uma biblioteca específica, talvez seja necessário atualizar uma biblioteca por meio do ambiente de prompt do Anaconda. Verifique se o ambiente de prompt Anaconda indica que todas as bibliotecas foram baixadas e instaladas. Siga as etapas para Baixar as bibliotecas de IA do Python, conforme descrito em um módulo anterior.

  • Se você encontrar erros no Visual Studio Code, tente reiniciar o aplicativo, reiniciar o kernel myenv e executar as células no arquivo de Jupyter Notebook.

  • Se possível, tente concluir os exercícios de todos os módulos no roteiro de aprendizagem em uma só sessão. Tente não fechar seu ambiente de prompt do Anaconda ou Visual Studio Code.

Criar uma rede neural

Depois de confirmar que seu ambiente está ativo, você estará pronto para criar uma rede neural para seu modelo de IA.

Detectar o tipo de dispositivo

Precisamos ajudar seu computador a determinar a maneira mais eficiente de criar a rede de aprendizado profundo. Primeiro, precisamos encontrar o tipo de dispositivo que você está usando: CPU ou GPU. As APIs PyTorch dão suporte para formar uma rede neural de acordo com o tipo de dispositivo.

  • Adicione o código a seguir em uma nova célula e depois execute a célula.

    # Determine if you're using a CPU or a GPU device to build the deep learning network
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = models.resnet50(pretrained=True)

    Depois que o sistema detecta o dispositivo, ele baixa as estruturas de modelo apropriadas para a localização de instalação do PyTorch em seu computador.

Criar neurônios e conectar a rede

Vamos adicionar código ao arquivo de Jupyter Notebook para criar os neurônios e conectar a rede.

  • Adicione o código a seguir em uma nova célula e depois execute a célula.

    # Build all the neurons
for param in model.parameters():
     param.requires_grad = False

# Wire the neurons together to create the neural network
model.fc = nn.Sequential(nn.Linear(2048, 512),
                               nn.ReLU(),
                               nn.Dropout(0.2),
                               nn.Linear(512, 2),
                               nn.LogSoftmax(dim=1))

criterion = nn.NLLLoss()
optimizer = optim.Adam(model.fc.parameters(), lr=0.003)

# Add the neural network to the device
model.to(device)

print('done')

    Quando o build for concluído, a saída do comando mostrará que o processo foi concluído:

    done

A rede neural é executada várias vezes até que ela aprenda as melhores associações (conexões) entre as características e os tipos de rochas.

Dynamic diagram that demonstrates how neural networks are created to train a learning model.

Crédito de visualização: Grant Sanderson, https://www.3blue1brown.com/.