Construindo um Modelo de Rede Neural e Realizando Previsões com Python para Inteligência Artificial (IA)

Se você está dando os primeiros passos no universo da Inteligência Artificial (IA), o Python é uma escolha excepcional para iniciar sua jornada, pois é amplamente utilizado na construção de ferramentas para IA. Neste guia, vamos explorar um dos pilares fundamentais da IA: as redes neurais.

O que é uma Rede Neural?

Uma rede neural é um sistema que aprende a fazer previsões por meio dos seguintes passos:

Recebimento dos dados de entrada.
Realização de uma previsão.
Comparação da previsão com o resultado desejado.
Ajuste dos parâmetros internos para obter previsões precisas futuramente.

Vetores, Camadas e Regressão Linear

Para compreender as redes neurais, é essencial ter familiaridade com conceitos básicos. Um deles é o vetor, que se trata de uma sequência de números. Utilizamos bibliotecas como NumPy para manipular vetores de maneira eficaz.

Outro conceito importante é a regressão linear, uma técnica de aprendizado de máquina empregada para modelar a relação entre variáveis independentes e dependentes.

O Processo de Treinamento de uma Rede Neural

Imagine que você esteja aprendendo a fazer malabarismos. Inicialmente, as bolas que você arremessa podem cair. Com a prática, você aprimora sua força e coordenação para pegá-las. Analogamente, uma rede neural começa com pesos e viés aleatórios. Ao ser treinada, ela ajusta esses parâmetros para realizar previsões mais acuradas.

Desenvolvendo uma Rede Neural Simples

Vamos começar implementando uma rede neural simples em Python. Antes disso, assegure-se de ter as bibliotecas NumPy e Matplotlib instaladas. Se não estiverem, você pode instalar com o seguinte comando:

Agora, podemos prosseguir com o desenvolvimento. Inicie o interpretador interativo Python (IPython) utilizando o comando ‘ipython’.

Construção da Classe NeuralNetwork

Primeiramente, construiremos a classe NeuralNetwork, que representa a estrutura fundamental da nossa rede neural. Essa classe englobará funções para realizar previsões, calcular gradientes e atualizar os parâmetros.

import numpy as np
import matplotlib.pyplot as plt

class NeuralNetwork:
    def __init__(self, learning_rate):
        self.weights = np.array([np.random.randn(), np.random.randn()])
        self.bias = np.random.randn()
        self.learning_rate = learning_rate

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        return self.sigmoid(x) * (1 - self.sigmoid(x))

    def predict(self, input_vector):
        layer_1 = np.dot(input_vector, self.weights) + self.bias
        layer_2 = self.sigmoid(layer_1)
        prediction = layer_2
        return prediction

    def compute_gradients(self, input_vector, target):
        layer_1 = np.dot(input_vector, self.weights) + self.bias
        layer_2 = self.sigmoid(layer_1)
        prediction = layer_2
        derror_dprediction = 2 * (prediction - target)
        dprediction_dlayer1 = self.sigmoid_derivative(layer_1)
        dlayer1_dbias = 1
        dlayer1_dweights = input_vector
        derror_dbias = derror_dprediction * dprediction_dlayer1 * dlayer1_dbias
        derror_dweights = derror_dprediction * dprediction_dlayer1 * dlayer1_dweights
        return derror_dbias, derror_dweights

    def update_parameters(self, derror_dbias, derror_dweights):
        self.bias = self.bias - (derror_dbias * self.learning_rate)
        self.weights = self.weights - (derror_dweights * self.learning_rate)

    def train(self, input_vectors, targets, num_epochs):
        training_errors = []

        for epoch in range(num_epochs):
            epoch_errors = 0
            for input_vector, target in zip(input_vectors, targets):
                derror_dbias, derror_dweights = self.compute_gradients(input_vector, target)
                self.update_parameters(derror_dbias, derror_dweights)
                epoch_errors += (target - self.predict(input_vector)) ** 2

            training_errors.append(epoch_errors)

            if epoch % 1000 == 0:
                print(f"Epoch {epoch}, Error: {epoch_errors}")

        return training_errors

Treinando a Rede Neural

Agora que a estrutura da rede neural está pronta, é possível treiná-la utilizando dados. Vamos criar vetores de entrada e alvos para ilustrar o processo.

input_vectors = np.array([
    [3, 1.5],
    [2, 1],
    [4, 1.5],
    [3, 4],
    [3.5, 0.5],
    [2, 0.5],
    [5.5, 1],
    [1, 1]
])

targets = np.array([0, 1, 0, 1, 0, 1, 1, 0])

learning_rate = 0.1
neural_network = NeuralNetwork(learning_rate)

num_epochs = 10000
training_errors = neural_network.train(input_vectors, targets, num_epochs)

Visualizando os Erros de Treinamento

Com a rede neural treinada, podemos plotar os erros de treinamento ao longo das iterações.

plt.plot(training_errors)
plt.xlabel("Epoch")
plt.ylabel("Error")
plt.title("Training Error over Epochs")
plt.show()

Conclusão

Neste artigo implementamos uma rede neural simples em Python e a treinamos para realizar previsões. Tenha em mente que este é apenas o início do empolgante mundo da Inteligência Artificial, repleto de redes neurais mais complexas para serem exploradas!

Esperamos que este artigo tenha oferecido uma base sólida para compreender redes neurais. Se desejar aprofundar-se ainda mais, sugerimos explorar bibliotecas populares como TensorFlow e PyTorch. Com essas ferramentas, você poderá construir redes neurais mais avançadas, capazes de resolver uma ampla gama de desafios.