Vou ajustar as fórmulas para que fiquem formatadas corretamente em LaTeX.

1. Introdução à Inteligência Artificial (IA)

A Inteligência Artificial (IA) é um ramo da ciência da computação que se concentra em criar sistemas capazes de realizar tarefas que, normalmente, exigiriam inteligência humana. Essas tarefas incluem reconhecimento de fala, aprendizado, planejamento e resolução de problemas.

IA pode ser dividida em duas categorias principais:

• IA Estreita (Narrow AI): Projetada para executar uma tarefa específica, como reconhecimento de imagem ou processamento de linguagem natural. Exemplo: assistentes virtuais como Siri ou Alexa.
• IA Geral (General AI): Uma IA que poderia executar qualquer tarefa cognitiva que um ser humano pode. Este nível de IA ainda está no campo teórico e não foi alcançado.

2. O que é um Perceptron

Um perceptron é um modelo matemático que tenta simular o comportamento de um neurônio biológico. Ele é o bloco de construção básico das redes neurais artificiais. O perceptron recebe múltiplas entradas, aplica pesos a elas, soma essas entradas ponderadas e, em seguida, passa o resultado através de uma função de ativação para produzir uma saída.

A fórmula básica do perceptron é:

3. Implementação de um Perceptron em Python

Vamos implementar um perceptron simples que aprende a realizar uma operação lógica AND. A operação AND retorna 1 se ambas as entradas forem 1, caso contrário, retorna 0.

import numpy as np

# Função de ativação - Degrau
def step_function(x):
    return 1 if x >= 0 else 0

# Classe Perceptron
class Perceptron:
    def __init__(self, input_size, learning_rate=0.1, epochs=1000):
        self.weights = np.zeros(input_size + 1)  # Pesos inicializados com 0
        self.learning_rate = learning_rate
        self.epochs = epochs

    def predict(self, x):
        # Adiciona o bias (termo de interceptação)
        x = np.insert(x, 0, 1)
        # Calcula a soma ponderada e aplica a função de ativação
        weighted_sum = np.dot(self.weights, x)
        return step_function(weighted_sum)

    def fit(self, X, y):
        # Treinamento do perceptron
        for _ in range(self.epochs):
            for i in range(y.size):
                prediction = self.predict(X[i])
                # Calcula o erro
                error = y[i] - prediction
                # Atualiza os pesos
                self.weights[1:] += self.learning_rate * error * X[i]
                self.weights[0] += self.learning_rate * error

# Dados de treinamento para a operação AND
X = np.array([
    [0, 0],
    [0, 1],
    [1, 0],
    [1, 1]
])

# Labels correspondentes
y = np.array([0, 0, 0, 1])

# Cria o perceptron
perceptron = Perceptron(input_size=2)

# Treina o perceptron
perceptron.fit(X, y)

# Testa o perceptron
print("Pesos finais:", perceptron.weights)
print("Predição para [0, 0]:", perceptron.predict([0, 0]))
print("Predição para [0, 1]:", perceptron.predict([0, 1]))
print("Predição para [1, 0]:", perceptron.predict([1, 0]))
print("Predição para [1, 1]:", perceptron.predict([1, 1]))

Explicação do Código

• Função de Ativação: Utilizamos uma função degrau simples que retorna 1 se a entrada é maior ou igual a 0, caso contrário retorna 0.
• Classe Perceptron: Esta classe define o perceptron. O método __init__ inicializa os pesos, a taxa de aprendizado, e o número de épocas. O método predict calcula a saída do perceptron, e o método fit ajusta os pesos durante o treinamento.
• Treinamento: O perceptron é treinado utilizando o algoritmo de aprendizado supervisionado, onde os pesos são atualizados de acordo com o erro (diferença entre a previsão e o valor real).

Testando o Perceptron

Após o treinamento, o perceptron deve ser capaz de prever corretamente o resultado da operação AND: