Dáphine Cristine - Fundamentos da Inteligência Artificial (1)

Prévia do material em texto

UNIVERSIDADE PITÁGORAS UNOPAR ANHANGUERA
ENGENHARIA DE SOFTWARE
DÁPHINE CRISTINE BARBOSA DE MELO
FUNDAMENTOS DA INTELIGÊNCIA ARTIFICIAL
Unidade: U4 _ REDES NEURAIS ARTIFICIAIS
Aula: A4_ ALGORITMOS DE REDES NEURAIS
NOVA FRIBURGO
2024
DÁPHINE CRISTINE BARBOSA DE MELO
FUNDAMENTOS DA INTELIGÊNCIA ARTIFICIAL
Trabalho apresentado à Universidade, como requisito
parcial para a obtenção de média semestral nas
disciplinas norteadoras do semestre letivo.
Tutor (a): Vanessa Matias Leite
1
NOVA FRIBURGO
2024
SUMÁRIO
1 INTRODUÇÃO.......................................................................................................... 3
2 MÉTODOS E RESULTADOS....................................................................................4
3 CONCLUSÃO........................................................................................................... 5
1 INTRODUÇÃO
Nesta atividade, foi explorado o funcionamento de uma Rede Neural Artificial
(RNA), um modelo de computação inspirado no funcionamento do cérebro humano.
O objetivo foi implementar uma RNA capaz de resolver o problema lógico do XOR,
que exige a identificação de padrões não lineares.Foi utilizados conceitos
2
fundamentais como a função de ativação sigmóide, o ajuste de pesos e o processo
de treinamento, que consiste em ensinar a rede a responder corretamente a partir de
exemplos. Ao longo da atividade, observei como a rede se ajusta e melhora suas
previsões com base no feedback recebido, culminando em um entendimento prático
de como as redes neurais funcionam na prática.
# Importação das Bibliotecas Necessárias
import numpy as np
# Definição da Função Sigmoide
def sigmoid(x, deriv=False):
if deriv:
return x * (1 - x)
return 1 / (1 + np.exp(-x))
# Definição das Entradas e Saídas
X = np.array([[0, 0],
[0, 1],
[1, 0],
[1, 1]]) # Matriz de entrada
y = np.array([[0], [1], [1], [0]]) # Matriz de saída
# Inicialização dos Pesos
np.random.seed(1)
weights0 = 2 * np.random.rand(2, 8) - 1 # Camada oculta com 8 neurônios
weights1 = 2 * np.random.rand(8, 1) - 1 # Saída
3
# Taxa de aprendizado
learning_rate = 0.1
# Treinamento da Rede Neural
for i in range(20000): # Aumentando o número de iterações
# Propagação para Frente
layer0 = X
layer1 = sigmoid(np.dot(layer0, weights0)) # Primeira camada oculta
layer2 = sigmoid(np.dot(layer1, weights1)) # Camada de saída
# Calcular Erro
layer2_error = y - layer2
# Calcular o Delta (ajuste dos pesos da saída)
layer2_delta = layer2_error * sigmoid(layer2, deriv=True)
# Calcular o erro e o delta da camada oculta
layer1_error = layer2_delta.dot(weights1.T)
layer1_delta = layer1_error * sigmoid(layer1, deriv=True)
# Atualizar os Pesos
weights1 += learning_rate * layer1.T.dot(layer2_delta)
weights0 += learning_rate * layer0.T.dot(layer1_delta)
# Exibição dos Resultados
4
print("Saída após o treinamento:")
print(layer2)
Saída após o treinamento:
[[0.03611529]
[0.96247335]
[0.96441349]
[0.03602855]]
2 MÉTODOS E RESULTADOS
5
Nesta atividade, foi implementada uma Rede Neural Artificial (RNA) para resolver o
problema lógico do XOR, utilizando os seguintes métodos:
1. Estrutura da Rede: A rede foi composta por uma camada de entrada com 2
neurônios, uma camada oculta com 8 neurônios e uma camada de saída com
1 neurônio. A função de ativação utilizada foi a sigmoide, que é adequada
para modelar a relação não linear do XOR.
2. Inicialização dos Pesos: Os pesos das conexões entre os neurônios foram
inicializados aleatoriamente, permitindo à rede começar o aprendizado de
forma variada.
3. Processo de Treinamento: A rede foi treinada em um loop que rodou por
20.000 iterações. Durante cada iteração:
○ Propagação para Frente: A entrada foi multiplicada pelos pesos,
passando pela camada oculta até chegar à saída.
○ Cálculo do Erro: O erro foi calculado comparando a saída prevista com
a saída esperada.
○ Ajuste de Pesos: Foi utilizado a derivada da função sigmóide para
calcular os deltas e ajustar os pesos da camada oculta e da camada de
saída.
4. Resultados: Após o treinamento, a rede apresentou as seguintes saídas para
as combinações de entrada do XOR:
○ Para [0, 0]: aproximadamente 0.03611529 (esperado: 0)
○ Para [0, 1]: aproximadamente 0.96247335 (esperado: 1)
○ Para [1, 0]: aproximadamente 0.96441349 (esperado: 1)
○ Para [1, 1]: aproximadamente 0.03602855 (esperado: 0)
Esses resultados indicam que a rede neural aprendeu a lógica do XOR de forma
eficaz, com as saídas muito próximas dos valores esperados. O aumento no número
de neurônios na camada oculta e a quantidade de iterações permitiram um
aprendizado mais eficiente, resultando em uma solução precisa para o problema.
6
3 CONCLUSÃO
Nesta atividade, foi implementada uma Rede Neural Artificial (RNA) para resolver o
problema lógico do XOR. Através de uma camada oculta e a função de ativação
sigmóide, a rede aprendeu a identificar padrões não lineares. O treinamento,
realizado em 20.000 iterações, resultou em saídas muito próximas dos valores
esperados, mostrando que a rede aprendeu corretamente a lógica do XOR. Essa
experiência destacou a importância da estrutura da rede e do ajuste dos pesos no
aprendizado, evidenciando a relevância das redes neurais na inteligência artificial.
7