PORTIFOLIO - FUNDAMENTOS DA INTELIGENCIA ARTIFICIAL

Prévia do material em texto

UNIVERSIDADE PITÁGORAS UNOPAR ANHANGUERA – UNOPAR 
 
 
 
 
 
ENGENHARIA DE SOFTWARE 
 
 
 
 
 
 
(ALUNO) 
 
 
 
 
 
 
Portifólio - Relatório de aula prática 
FUNDAMENTOS DA INTELIGÊNCIA ARTIFICIAL 
 
 
 
 
 
 
 
 
COLINAS DO TOCANTINS-TO 
2024
 
 
(ALUNO) 
 
 
 
 
 
 
Portifólio - Relatório de aula prática 
FUNDAMENTOS DA INTELIGÊNCIA ARTIFICIAL 
 
 
 
 
 
 
 
 
Relatório de aula prática apresentado no curso 
de Engenharia de Software como requisito 
parcial para a obtenção de pontos na matéria 
de Fundamentos da Inteligência Artificial para 
a média semestral. 
Tutor: Vinicius Camargo Prattes 
 
 
 
 
 
 
 
 
COLINAS DO TOCANTINS-TO 
2024
 
 
SUMÁRIO 
 
1. INTRODUÇÃO ............................................................................................................. 3 
2. MÉTODOS ..................................................................................................................... 4 
3. RESULTADOS ............................................................................................................... 7 
4. CONCLUSÃO ................................................................................................................ 8 
REFERÊNCIAS ....................................................................................................................... 9 
 
 
 
 
 
 
 
 
3 
 
1. INTRODUÇÃO 
 
O JDoodle Python é uma plataforma online que oferece um ambiente de 
desenvolvimento integrado (IDE) diretamente no navegador, permitindo aos usuários 
programar em Python de maneira prática e eficiente. Ele é amplamente utilizado para 
aprendizado e desenvolvimento, especialmente em áreas como ciência de dados, inteligência 
artificial e aprendizado de máquina. O JDoodle Python simplifica a execução de código, 
oferecendo recursos como realce de sintaxe, sugestões de código e feedback imediato, o que 
facilita a escrita e depuração de programas. 
Neste trabalho, usaremos o JDoodle Python para implementar uma rede neural 
artificial (RNA) simples de uma camada, cujo objetivo é realizar a tarefa de classificação 
binária. As redes neurais artificiais (RNAs) são modelos computacionais inspirados no 
funcionamento do cérebro humano, capazes de realizar tarefas de classificação, previsão e 
reconhecimento de padrões. Implementaremos uma rede neural simples de uma camada 
(perceptron de camada única), com o objetivo de realizar uma tarefa de classificação binária. 
Para isso, utilizamos a função de ativação sigmoide, que transforma a saída do neurônio em 
um valor entre 0 e 1, adequado para problemas de classificação binária. A rede será treinada 
utilizando o método de aprendizado supervisionado, onde ajustaremos os pesos com base no 
erro entre a saída esperada e a saída real. O treinamento será feito em 10.000 iterações para 
garantir a convergência da rede. O JDoodle Python facilita a execução desse processo, 
permitindo o uso da biblioteca NumPy para realizar operações matemáticas e manipulação de 
arrays de maneira eficiente. 
 
 
4 
 
2. MÉTODOS 
 
Os seguintes métodos foram utilizados para realizar a atividade: 
 
• Bibliotecas utilizadas: A principal biblioteca utilizada será a NumPy que nos permite 
realizar operações matemáticas de forma eficiente e manipular arrays. 
• Função sigmoide: A função de ativação sigmoide transforma qualquer valor de entrada em 
um valor entre 0 e 1. Sua fórmula é dada por: 
Também usaremos sua derivada para calcular o gradiente durante o ajuste dos pesos: 
• Matriz de entrada e saída: Definimos a matriz de entrada X (dados de entrada) e matriz de 
saída e (saída desejada), que conterá os valores esperados para cada entrada. 
• Inicialização dos pesos: Os pesos da sinapse serão inicializados com valores aleatórios para 
garantir que a rede não comece em um estado simétrico. 
• Treinamento: Implementaremos um loop de treinamento, onde em cada iteração 
avançaremos a propagação para frente, design do erro, ajuste dos pesos e atualização dos 
mesmos. 
Abaixo, na imagem 1, o código escrito: 
Imagem 1 – Código em Python 
 
Fonte: Do Autor, 2024. 
 
Explicação do Código: 
5 
 
O código implementa uma rede neural artificial (RNA) de uma camada utilizando 
a função de ativação sigmoide. O objetivo é realizar uma classificação binária, ajustando os 
pesos da rede por meio de um processo de treinamento supervisionado. Vamos detalhar cada 
etapa do código: 
Linha 1 do código: importação da biblioteca NumPy: A biblioteca NumPy é importada 
para realizar operações matemáticas e manipular arrays de forma eficiente. Ela é essencial 
para criar e manipular as matrizes de entrada, saída e pesos. 
Linhas 4 e 5 do código: Função de ativação sigmoide: A função de ativação sigmoide é 
implementada para transformar as saídas dos neurônios em valores entre 0 e 1. Ela é uma 
função não linear e adequada para problemas de classificação binária. 
Linhas 8 e 9 do código: Derivada da função sigmoide: A derivada da função sigmoide é 
utilizada no cálculo do ajuste dos pesos durante o treinamento. Ela é necessária para calcular 
o gradiente no processo de retropropagação do erro. 
Linhas 13 a 19 do código: Definição das entradas (X) e saídas esperadas (y): Neste 
exemplo, criamos uma matriz X com quatro amostras de três entradas cada (0 ou 1), e uma 
matriz y com as saídas esperadas para cada amostra. O objetivo é treinar a rede para que, dada 
uma entrada, ela produza a saída correspondente. 
Linhas 22 a 23 do código: Inicialização dos pesos: Os pesos (ou sinapses) são inicializados 
aleatoriamente para garantir que a rede neural comece de maneira não simétrica. Os valores 
são gerados entre -1 e 1 com distribuição uniforme. 
Linha 26 do código: Loop de treinamento: O treinamento ocorre em um loop de 10.000 
iterações, ajustando os pesos em cada ciclo. A cada iteração, a rede faz os seguintes passos: 
• Nas linhas 31 e 32 temos a propagação para frente: Calcula a saída da rede 
(ativação do neurônio) com base na multiplicação da matriz de entrada pelos pesos e 
aplicando a função sigmoide. 
• Na linha 35 temos o cálculo do erro: O erro é a diferença entre a saída real da 
rede (calculada) e a saída esperada (y). Esse erro será usado para ajustar os pesos. 
• Na linha 38 temos o Ajuste dos pesos: Utilizando a derivada da função 
sigmoide, calcula-se o "delta" ou o ajuste necessário para os pesos. Este ajuste é 
aplicado aos pesos na próxima iteração. 
• Na linha 41 temos a Atualização dos pesos: Os pesos são atualizados 
somando o ajuste calculado à multiplicação da matriz de entrada transposta pelo 
6 
 
delta (ajuste). Isso permite que os pesos sejam ajustados para reduzir o erro nas 
próximas iterações. 
Linhas 44 e 45 do código: Exibição dos resultados: Após o término das 10.000 iterações, o 
código imprime a saída da rede neural, mostrando como ela aprendeu a tarefa de classificação 
binária, aproximando-se das saídas esperadas (0 ou 1). 
No final, a rede consegue aprender a relação entre as entradas e as saídas, realizando 
corretamente a classificação binária. 
 
7 
 
3. RESULTADOS 
 
Após a execução do treinamento por 10.000 iterações, a rede neural ajusta os pesos 
de maneira que a saída calculada se aproxime das saídas desejadas para cada entrada. Abaixo, 
o resultado após o treinamento: 
Imagem 2 – Resultado (saída) 
 
Fonte: Do Autor, 2024. 
 
A saída da rede é muito próxima dos valores desejados: 0 e 1. Isso demonstra que o 
treinamento foi eficaz na tarefa de classificação binária, ajustando os pesos de forma que a 
rede fosse capaz de aprender o padrão de entradas e suas respectivas saídas. 
 
8 
 
4. CONCLUSÃO 
 
Neste trabalho, criamos uma rede neural simples de uma camada para resolver um 
problema de classificação binária. Usamos a função de ativação sigmoide e, por meio de um 
processo de aprendizado supervisionado, ajustamos os pesos da redepara que as saídas 
ficassem cada vez mais próximas dos valores esperados. A rede conseguiu aprender a relação 
entre os dados de entrada e suas respectivas saídas, o que mostrou a eficiência do modelo para 
a tarefa. O treinamento foi bem-sucedido e destacou a importância da função de ativação e do 
ajuste dos pesos no aprendizado de redes neurais. 
 
9 
 
REFERÊNCIAS 
 
NUMPY. Biblioteca NumPy. Disponível em: https://numpy.org/. Acesso em: 24 set. 2024. 
 
JDOODLE. JDoodle - Python IDE Online. Disponível em: 
https://www.jdoodle.com/python3-programming-online. Acesso em: 24 set. 2024. 
 
ALURA. Rede neural artificial: Uma introdução. Disponível em: 
https://www.alura.com.br/conteudo/pln-deep-learning. Acesso em: 24 set. 2024. 
 
PYTHON. Python - Documentação oficial. Disponível em: https://docs.python.org/3/. 
Acesso em: 24 set. 2024. 
 
https://numpy.org/
https://www.jdoodle.com/python3-programming-online
https://www.alura.com.br/conteudo/pln-deep-learning
https://docs.python.org/3/