As redes neurais são um conceito importante nas áreas de inteligência artificial e aprendizado de máquina. Eles consistem em nós interconectados, organizados em camadas, e imitam o funcionamento do cérebro humano. Os nós representam os neurônios do cérebro humano.
Você pode criar sua própria rede neural de classificação multiclasse de feed-forward simples. Treine-o para classificar dígitos manuscritos usando o conjunto de dados MNIST. Você pode então usar a visão computacional para classificar seus próprios dígitos manuscritos.
O que é classificação multiclasse?
A classificação multiclasse é um tipo de aprendizado de máquina que pode classificar dados em mais de duas categorias. As redes neurais usam o classificador softmax para distribuir a probabilidade sobre classes possíveis.
Você pode usar a classificação multiclasse para classificar imagens manuscritas do conjunto de dados MNIST em 10 categorias. Essas categorias corresponderão aos dígitos de 0 a 9.
Compreendendo o conjunto de dados MNIST
O conjunto de dados MNIST é um conjunto de dados de referência popular para algoritmos de aprendizado de máquina e visão computacional. Ele contém 70.000 imagens manuscritas em tons de cinza com tamanho de 28 por 28 pixels. Os dígitos manuscritos estão no intervalo de 0 a 9.
Antes de criar qualquer modelo de aprendizado de máquina, é importante entender o que seu conjunto de dados contém. Compreender o conjunto de dados permitirá que você execute um melhor pré-processamento de dados.
Preparando seu ambiente
Para seguir este tutorial, você deve estar familiarizado com o noções básicas de Python. Você também deve ter um conhecimento básico de aprendizado de máquina. Por fim, você deve se sentir confortável usando o Jupyter Notebook ou o Google Colab.
O código-fonte completo está disponível em um Repositório GitHub.
Crie um novo Jupyter Notebook ou entre em Google Colab. Execute este comando para instalar os pacotes necessários:
!pip instalar numpy matplotlib tensorflow opencv-python
Você vai usar:
- Matplotlib para visualização de dados.
- NumPy para manipular matrizes.
- TensorFlow para criar e treinar seu modelo.
- OpenCV para alimentar o modelo com seus próprios dígitos manuscritos.
Importando os Módulos Necessários
Importe os pacotes que você instalou em seu ambiente. Isso permitirá que você chame e use posteriormente suas funções e módulos em seu código.
importar tensorflow como tf
de tensorflow importar keras
importar matplotlib.pyplot como plt
%matplotlib embutido
importar entorpecido como np
importar cv2A segunda linha de código importa o módulo Keras do Biblioteca do Google TensorFlow. Você usará o Keras para treinar sua rede neural profunda com o TensorFlow como back-end.
Carregando e visualizando o conjunto de dados
O conjunto de dados MNIST é integrado ao Keras. Carregue o conjunto de dados MNIST e divida-o em conjuntos de treinamento e teste. Você usará o conjunto de treinamento para treinar seu modelo e o conjunto de teste para avaliar a precisão de seu modelo na classificação de novas imagens não vistas.
(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()
Verifique a duração dos conjuntos de treinamento e teste. O conjunto de dados MNIST possui 60.000 imagens para treinamento e 10.000 imagens para teste.
len (X_train)
len (teste_X)Verifique a forma da primeira imagem no conjunto de dados MNIST, que deve ser de 28 por 28 pixels. Em seguida, imprima seus valores de pixel e visualize-os usando o Matplotlib.
X_train[0].forma
X_train[0]
plt.matshow (X_train[0])
y_train[0]A saída da visualização é a seguinte:
A imagem visualizada mostra que a primeira imagem no conjunto de dados contém o número cinco.
Pré-processamento de dados
Antes de usar os dados no conjunto de dados para treinar e testar seu modelo, você precisa pré-processá-lo. O pré-processamento aumenta a precisão de um modelo padronizando os dados.
Normalizando os valores de pixel
Normalize os valores de pixel das imagens no conjunto de dados dividindo cada valor por 255. Os valores de pixel do conjunto de dados não normalizados variam de 0 a 255, sendo zero preto e 255 branco. A divisão de cada valor de pixel por 255 garante que cada pixel esteja no intervalo entre 0 e 1. Isso torna mais fácil para o modelo aprender os recursos e padrões relevantes nos dados.
Trem_X = Trem_X / 255
X_teste = X_teste / 255Em seguida, imprima os valores de pixel da primeira imagem.
X_train[0]Observe que agora eles estão no intervalo entre 0 e 1.
Convertendo as matrizes de imagem em uma matriz 1D
A camada de entrada da rede neural geralmente espera entradas 1D, então crie uma matriz 1D dos valores de pixel da imagem. Para fazer isso, use a função reshape() com o número de raws definido como o número de imagens no conjunto de dados.
X_train_flattened = X_train.reshape (len (X_train), 28 * 28)
X_test_flattened = X_test.reshape (len (X_test), 28 * 28)
X_train_flattened.shape
X_train_flattened[0]
Suas imagens agora estão prontas para treinar e testar o modelo.
Criando o modelo de rede neural profunda
Crie um modelo sequencial com o módulo Keras do Tensorflow usando uma camada de entrada, duas camadas ocultas e uma camada de saída. Defina a forma de entrada para 28 por 28, pois esta é a forma das imagens originais no conjunto de dados. Use 128 nós para as camadas ocultas. A camada de saída deve ter apenas 10 neurônios, pois você está classificando apenas os dígitos de 0 a 9.
modelo = keras. Sequencial([
keras.layers. Achatar (input_shape=(28, 28)),keras.layers. Denso(128, ativação='relu'),
keras.layers. Denso(128, ativação='relu'),
keras.layers. Denso(10, ativação='softmax')
])
Compile o modelo usando o Adão otimizador, sparse_categorical_crossentropy como a função de perda, e a métrica para avaliar o desempenho do modelo como precisão. Em seguida, ajuste os dados de treinamento ao modelo e defina o número de épocas para cinco.
model.compile (otimizador='Adão',
perda ='sparse_categorical_crossentropy',
métricas=['precisão'])
model.fit (X_train, y_train, épocas=5)
O modelo levará alguns minutos para treinar. Após a conclusão do treinamento do modelo, avalie seu desempenho no conjunto de teste.
model.evaluate (X_test, y_test)
A função de avaliação retornará a perda e a precisão do modelo. O modelo produz uma precisão de 98%.
Usando o modelo para classificar seus próprios dígitos manuscritos
Para classificar seus próprios dígitos manuscritos, você precisa preparar suas imagens para corresponder às do conjunto de dados MNIST. Deixar de fazer isso fará com que seu modelo tenha um desempenho ruim.
Para pré-processar as imagens:
- Carregue a imagem contendo o dígito usando o OpenCV.
- Converta-o em escala de cinza e redimensione-o para 28 por 28 pixels.
- Inverta e normalize os valores de pixel.
- Por fim, nivele a imagem em uma matriz 1D.
Passe a imagem pré-processada para o modelo de previsão e imprima o valor previsto na tela.
img = cv2.imread('dígitos/dígito1.png', cv2.IMREAD_GRAYSCALE)
img_resize = cv2.resize (img, (28, 28))
img_flip = cv2.bitwise_not (img_resize)
img_normalized = img_flip.astype('float32') / 255.0# Achate a imagem em uma matriz 1D
input_data = img_normalized.flatten().reshape( 1,28,28)
# Faça uma previsão usando o modelo
predição = model.predict (input_data)
imprimir (f'Previsão: {np.argmax (previsão)}')
Passando uma imagem pré-processada contendo um número para o modelo.
A saída do modelo é a seguinte:
O modelo foi capaz de classificar corretamente o dígito sete.
Redes Neurais em Chatbots
O uso de redes neurais explodiu nos últimos anos. Eles têm sido predominantemente usados no processamento de linguagem natural para tradução de linguagem e IA generativa.
Mais recentemente, houve um aumento no número de chatbots que podem se comunicar de maneira humana. Eles usam um tipo de rede neural conhecida como rede neural transformadora. Interaja com alguns deles e experimente o poder das redes neurais.
