Arquivo de Machine Learning - Página 14 de 16

class Neuronio:
    def __init__(self):
        # x1, x2, x3
        self.entradas = [1, 0, 0.8]
        # w1, w2, w3
        self.pesos = [0.9, 0.3, 0.7]
        # bias
        self.bias = -0.5
    
    def funcao_ativacao(self, soma):
        # Função degrau - simples "sim ou não"
        return 1 if soma >= 0 else 0
    
    def calcular_saida(self):
        soma_ponderada = (self.entradas[0] * self.pesos[0] + 
                         self.entradas[1] * self.pesos[1] + 
                         self.entradas[2] * self.pesos[2] + 
                         self.bias)

        saida = self.funcao_ativacao(soma_ponderada)

        return saida, soma_ponderada

# ✅ CORRETO: Criar uma INSTÂNCIA da classe
neuronio = Neuronio()  # Isso aqui é importante!
saida, soma_ponderada = neuronio.calcular_saida()  # Chamar na instância

print("=== SEU ENTENDIMENTO CONFIRMADO ===")
print(f"Entradas (x): {neuronio.entradas}")
print(f"Pesos (w): {neuronio.pesos}")
print(f"Bias: {neuronio.bias:.2f}")
print(f"Média Ponderada: {neuronio.entradas[0]}*{neuronio.pesos[0]} + {neuronio.entradas[1]}*{neuronio.pesos[1]} + {neuronio.entradas[2]}*{neuronio.pesos[2]} + {neuronio.bias} = {soma_ponderada:.2f}")
print(f"Saída: {saida}")

"""
==========
RESULTADO
==========
=== SEU ENTENDIMENTO CONFIRMADO ===
Entradas (x): [1, 0, 0.8]
Pesos (w): [0.9, 0.3, 0.7]
Bias: -0.50
Média Ponderada: 1*0.9 + 0*0.3 + 0.8*0.7 + -0.5 = 0.96
Saída: 1

"""

class Neuronio:

def __init__(self):

# x1, x2, x3

self.entradas = [1, 0, 0.8]

# w1, w2, w3

self.pesos = [0.9, 0.3, 0.7]

# bias

self.bias = -0.5

def funcao_ativacao(self, soma):

# Função degrau - simples "sim ou não"

return 1 if soma >= 0 else 0

def calcular_saida(self):

soma_ponderada = (self.entradas[0] * self.pesos[0] +

self.entradas[1] * self.pesos[1] +

self.entradas[2] * self.pesos[2] +

self.bias)

saida = self.funcao_ativacao(soma_ponderada)

return saida, soma_ponderada

# ✅ CORRETO: Criar uma INSTÂNCIA da classe

neuronio = Neuronio() # Isso aqui é importante!

saida, soma_ponderada = neuronio.calcular_saida() # Chamar na instância

print("=== SEU ENTENDIMENTO CONFIRMADO ===")

print(f"Entradas (x): {neuronio.entradas}")

print(f"Pesos (w): {neuronio.pesos}")

print(f"Bias: {neuronio.bias:.2f}")

print(f"Média Ponderada: {neuronio.entradas[0]}*{neuronio.pesos[0]} + {neuronio.entradas[1]}*{neuronio.pesos[1]} + {neuronio.entradas[2]}*{neuronio.pesos[2]} + {neuronio.bias} = {soma_ponderada:.2f}")

print(f"Saída: {saida}")

"""

==========

RESULTADO

==========

=== SEU ENTENDIMENTO CONFIRMADO ===

Entradas (x): [1, 0, 0.8]

Pesos (w): [0.9, 0.3, 0.7]

Bias: -0.50

Média Ponderada: 1*0.9 + 0*0.3 + 0.8*0.7 + -0.5 = 0.96

Saída: 1

"""

A diferença de Perceptron e Neurônio Artificaial

- Apesar de frequentemente utilizados como sinônimos, perceptrons e neurônios artificiais representam conceitos com diferenças fundamentais na inteligência artificial. Embora ambos compartilhem a mesma inspiração biológica e estrutura básica – composta por entradas, pesos, bias e função de ativação – suas características distintivas definem aplicações e capacidades bastante específicas.

A Função de Ativação: O Divisor de Águas

- A diferença mais crucial reside na função de ativação empregada. O perceptron, em sua forma clássica, utiliza exclusivamente a função degrau, resultando em saídas estritamente binárias (0 ou 1). Esta característica o torna adequado para problemas de classificação linearmente separáveis, mas limita sua aplicação em cenários mais complexos. Em contraste, o neurônio artificial moderno pode incorporar diversas funções de ativação – como sigmoide, tanh, ReLU ou softmax – permitindo saídas contínuas e multivariadas que abrem portas para problemas de regressão e classificação não-linear.

Contexto Histórico e Evolutivo

- O perceptron emerge como pioneiro, desenvolvido por Frank Rosenblatt em 1957, representando o primeiro modelo concretizado de neurônio artificial. Sua simplicidade inicial, porém, revelou limitações que levaram a invernos da IA, particularmente na resolução de problemas não linearmente separáveis. O neurônio artificial, como conceito amplo, evoluiu para superar estas restrições, incorporando arquiteturas multicamadas e funções de ativação mais sofisticadas.

Aplicações e Capacidades

Enquanto os perceptrons são tipicamente organizados em camadas únicas ou redes de poucas camadas, os neurônios artificiais contemporâneos formam a base das redes neurais profundas, com múltiplas camadas ocultas. Esta distinção arquitetural reflete-se diretamente na capacidade de aprendizado: o perceptron segue a regra do perceptron para ajuste de pesos, adequada para problemas lineares, enquanto os neurônios artificiais em redes profundas utilizam backpropagation com gradiente descendente, permitindo a modelagem de relações não-lineares complexas.

Conclusão

Em essência, a relação entre estes conceitos pode ser entendida como hierárquica: todo perceptron é um neurônio artificial, mas a recíproca não é verdadeira. O perceptron permanece como um caso específico dentro do espectro mais amplo de neurônios artificiais, cada um com suas vantagens e aplicações particulares no vasto ecossistema do aprendizado de máquina moderno.

Orientado a Objeto

import numpy as np

class Neuronio:
    def __init__(self, entradas, pesos, bias=-0.5):
        if len(entradas) != len(pesos):
            raise ValueError(
                f"ERRO:\n"
                f"   Número de Entradas : {len(entradas)}\n"
                f"   Número de Pesos: {len(pesos)}\n"
                f"   Número de Entradas e Pesos são DIFERENTES."
            )
        self.entradas = np.array(entradas)
        self.pesos = np.array(pesos)
        self.bias = bias
    
    @property
    def somatorio(self):
        # Σ = (X1 * W1) + ... + (Xn * Wn)
        return np.dot(self.entradas, self.pesos)
    
    @property
    def total(self):
        # total = Σ + bias
        return self.somatorio + self.bias
    
    @property
    def funcao_ativacao(self):
        return 1 if self.total >= 0 else 0
    
    @property
    def saida(self):
        return self.funcao_ativacao
    
    def __str__(self):
        """Representação em string do neurônio - para print()"""
        return (
            f"NEURÔNIO ARTIFICIAL\n"
            f"├── Entradas: {list(self.entradas.tolist())}\n"
            f"├── Pesos:    {list(self.pesos.tolist())}\n"
            f"├── Bias:     {self.bias}\n"
            f"├── Somatório: {self.somatorio:.2f}\n"
            f"├── Total:     {self.total:.2f}\n"
            f"└── Saída:  {self.saida} {'Ativado' if self.saida == 1 else 'Desativado'}"
        )
    
    def mostrar_calculo_detalhado(self):
        print("=" * 50)
        print("DETALHAMENTO")
        print("=" * 50)
        
        for i in range(len(self.entradas)):
            calc = self.entradas[i] * self.pesos[i]
            print(f"x{i+1} * w{i+1} = {self.entradas[i]} * {self.pesos[i]} = {calc:.2f}")
        
        print(
            f"NEURÔNIO ARTIFICIAL\n"
            f"├── Entradas: {list(self.entradas.tolist())}\n"
            f"├── Pesos:    {list(self.pesos.tolist())}\n"
            f"├── Bias:     {self.bias}\n"
            f"├── Somatório: {self.somatorio:.2f}\n"
            f"├── Total:     {self.total:.2f}\n"
            f"└── Saída:  {self.saida} {'Ativado' if self.saida == 1 else 'Desativado'}")

# TESTE

entradas = [1, 0, 0.8]
pesos = [0.9, 0.3, 0.7]

neuronio = Neuronio(entradas, pesos)
print(neuronio)  # Automaticamente chama __str__
neuronio.mostrar_calculo_detalhado()

"""
NEURÔNIO ARTIFICIAL
├── Entradas: [1.0, 0.0, 0.8]
├── Pesos:    [0.9, 0.3, 0.7]
├── Bias:     -0.5
├── Somatório: 1.46
├── Total:     0.96
└── Saída:  1 Ativado
==================================================
DETALHAMENTO
==================================================
x1 * w1 = 1.0 * 0.9 = 0.90
x2 * w2 = 0.0 * 0.3 = 0.00
x3 * w3 = 0.8 * 0.7 = 0.56
NEURÔNIO ARTIFICIAL
├── Entradas: [1.0, 0.0, 0.8]
├── Pesos:    [0.9, 0.3, 0.7]
├── Bias:     -0.5
├── Somatório: 1.46
├── Total:     0.96
└── Saída:  1 Ativado
"""

import numpy as np

class Neuronio:

def __init__(self, entradas, pesos, bias=-0.5):

if len(entradas) != len(pesos):

raise ValueError(

f"ERRO:\n"

f" Número de Entradas : {len(entradas)}\n"

f" Número de Pesos: {len(pesos)}\n"

f" Número de Entradas e Pesos são DIFERENTES."

)

self.entradas = np.array(entradas)

self.pesos = np.array(pesos)

self.bias = bias

@property

def somatorio(self):

# Σ = (X1 * W1) + ... + (Xn * Wn)

return np.dot(self.entradas, self.pesos)

@property

def total(self):

# total = Σ + bias

return self.somatorio + self.bias

@property

def funcao_ativacao(self):

return 1 if self.total >= 0 else 0

@property

def saida(self):

return self.funcao_ativacao

def __str__(self):

"""Representação em string do neurônio - para print()"""

return (

f"NEURÔNIO ARTIFICIAL\n"

f"├── Entradas: {list(self.entradas.tolist())}\n"

f"├── Pesos: {list(self.pesos.tolist())}\n"

f"├── Bias: {self.bias}\n"

f"├── Somatório: {self.somatorio:.2f}\n"

f"├── Total: {self.total:.2f}\n"

f"└── Saída: {self.saida} {'Ativado' if self.saida == 1 else 'Desativado'}"

)

def mostrar_calculo_detalhado(self):

print("=" * 50)

print("DETALHAMENTO")

print("=" * 50)

for i in range(len(self.entradas)):

calc = self.entradas[i] * self.pesos[i]

print(f"x{i+1} * w{i+1} = {self.entradas[i]} * {self.pesos[i]} = {calc:.2f}")

print(

f"NEURÔNIO ARTIFICIAL\n"

f"├── Entradas: {list(self.entradas.tolist())}\n"

f"├── Pesos: {list(self.pesos.tolist())}\n"

f"├── Bias: {self.bias}\n"

f"├── Somatório: {self.somatorio:.2f}\n"

f"├── Total: {self.total:.2f}\n"

f"└── Saída: {self.saida} {'Ativado' if self.saida == 1 else 'Desativado'}")

# TESTE

entradas = [1, 0, 0.8]

pesos = [0.9, 0.3, 0.7]

neuronio = Neuronio(entradas, pesos)

print(neuronio) # Automaticamente chama __str__

neuronio.mostrar_calculo_detalhado()

"""

NEURÔNIO ARTIFICIAL

├── Entradas: [1.0, 0.0, 0.8]

├── Pesos: [0.9, 0.3, 0.7]

├── Bias: -0.5

├── Somatório: 1.46

├── Total: 0.96

└── Saída: 1 Ativado

==================================================

DETALHAMENTO

==================================================

x1 * w1 = 1.0 * 0.9 = 0.90

x2 * w2 = 0.0 * 0.3 = 0.00

x3 * w3 = 0.8 * 0.7 = 0.56

NEURÔNIO ARTIFICIAL

├── Entradas: [1.0, 0.0, 0.8]

├── Pesos: [0.9, 0.3, 0.7]

├── Bias: -0.5

├── Somatório: 1.46

├── Total: 0.96

└── Saída: 1 Ativado

"""

Explore os conceitos fundamentais que formam a base das redes neurais artificiais, desde o simples perceptron até arquiteturas complexas de aprendizado profundo.

O Perceptron: O Neurônio Artificial

O que é um Perceptron?

O perceptron é a unidade fundamental das redes neurais, inspirado no neurônio biológico. Desenvolvido por Frank Rosenblatt em 1957, é um classificador linear simples.

Estrutura Matemática

Um perceptron calcula sua saída como:

\(y = f(\sum_{i=1}^{n} w_i x_i + b)\)

Onde:

\(x_i\) são as entradas
\(w_i\) são os pesos
\(b\) é o bias (viés)
\(f\) é a função de ativação

Limitações do Perceptron Simples

Um único perceptron só pode resolver problemas linearmente separáveis. Para problemas não-lineares, precisamos de múltiplos perceptrons organizados em camadas.

Redes Neurais: Conectando Perceptrons

Uma rede neural é uma coleção de perceptrons organizados em camadas, capaz de aprender relações complexas não-lineares nos dados.

Componentes Principais

Camada de Entrada: Recebe os dados brutos
Camadas Ocultas: Processam informações intermediárias
Camada de Saída: Produz o resultado final
Conexões: Pesos que representam a força das conexões

Complexidade

Maior capacidade de modelagem
Mais parâmetros para ajustar
Maior necessidade de dados
Tempo de treinamento aumentado

O Poder das Camadas Ocultas

Cada camada oculta adicional permite que a rede aprenda representações mais abstratas e complexas dos dados, seguindo a hierarquia:

Entradas → Características simples → Características complexas → Saída

Arquitetura de Redes Neurais

A arquitetura define como os neurônios são organizados e conectados na rede.

Feedforward (Alimentação Direta)

Informação flui em uma direção: entrada → ocultas → saída. Mais comum em problemas de classificação.

Redes Recorrentes (RNN)

Conexões formam ciclos, permitindo memória temporal. Ideal para sequências como texto ou áudio.

Convolucionais (CNN)

Especializadas em processar dados grid-like (imagens), usando operações de convolução.

Parâmetros vs. Hiperparâmetros
Parâmetros: Pesos e biases aprendidos durante o treinamento
Hiperparâmetros: Configurações definidas antes do treinamento

Hiperparâmetros Fundamentais

Otimizador de Gradientes

Controla como os pesos são atualizados durante o treinamento:

SGD: Gradiente Descendente Estocástico simples
Adam: Combina momentum e adaptação de taxa de aprendizado
RMSprop: Adapta taxa de aprendizado por parâmetro

Épocas (Epochs)

Número de vezes que o algoritmo processa todo o conjunto de treinamento. Muito poucas → underfitting, muitas → overfitting.

Taxa de Aprendizado (Learning Rate)

\(\alpha\) na fórmula do gradiente descendente. Controla o tamanho dos passos durante a otimização:

Muito alta: Pode divergir
Muito baixa: Convergência lenta

Tamanho do Lote (Batch Size)

Número de exemplos processados antes de atualizar os pesos:

Batch: Usa todo o dataset (estável mas lento)
Mini-batch: Compromisso entre velocidade e estabilidade
Stochastic: Um exemplo por vez (rápido mas ruidoso)

Funções de Ativação

Introduzem não-linearidade na rede:

Sigmoid: \(\sigma(x) = \frac{1}{1+e^{-x}}\)
ReLU: \(f(x) = max(0, x)\)
Tanh: \(tanh(x) = \frac{e^x – e^{-x}}{e^x + e^{-x}}\)

Funções de Custo (Loss Functions)

Medem o erro entre previsões e valores reais:

MSE: Para regressão
Cross-Entropy: Para classificação
Binary Cross-Entropy: Para classificação binária

Backpropagation: O Coração do Aprendizado

O que é Backpropagation?

Algoritmo fundamental para treinar redes neurais, calculando eficientemente o gradiente da função de custo em relação a todos os pesos da rede.

O Processo em Duas Fases
Forward Pass: Dados fluem pela rede, gerando previsões
Backward Pass: Gradientes são calculados e propagados de volta

Regra da Cadeia na Prática

O backpropagation usa a regra da cadeia do cálculo para calcular gradientes:

\(\frac{\partial C}{\partial w} = \frac{\partial C}{\partial a} \times \frac{\partial a}{\partial z} \times \frac{\partial z}{\partial w}\)

Onde \(C\) é o custo, \(a\) a ativação, \(z\) a entrada ponderada, e \(w\) o peso.

Por que é Eficiente?

Calcula todos os gradientes em uma única passagem para trás, evitando cálculos redundantes.

Desafios

Problemas como vanishing/exploding gradients podem ocorrer em redes muito profundas.

Fluxo Completo de Treinamento

Passo a Passo do Treinamento

Inicialização: Configurar arquitetura e hiperparâmetros
Forward Propagation: Calcular previsões
Cálculo do Custo: Medir erro das previsões
Backpropagation: Calcular gradientes
Atualização de Pesos: Ajustar pesos usando otimizador
Repetição: Voltar ao passo 2 até convergência

Relação entre Todos os Componentes

Os hiperparâmetros trabalham em conjunto: a taxa de aprendizado ideal depende do otimizador escolhido, que por sua vez é afetado pelo tamanho do lote. A função de ativação influencia como os gradientes fluem durante o backpropagation.

Conclusão: A Sinergia dos Componentes

O sucesso de uma rede neural depende da combinação harmoniosa de todos esses elementos. Desde a escolha da arquitetura adequada ao problema, passando pela seleção cuidadosa dos hiperparâmetros, até a implementação eficiente do backpropagation – cada componente desempenha um papel crucial no processo de aprendizado.

O backpropagation permanece como um dos algoritmos mais importantes na história da inteligência artificial, permitindo que redes com milhões de parâmetros aprendam representações complexas a partir de dados.

Referências e Leitura Adicional

Rosenblatt, F. (1958). The perceptron: A probabilistic model for information storage and organization in the brain.
Rumelhart, D. E., Hinton, G. E., & Williams, R. J. (1986). Learning representations by back-propagating errors.
Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning.
Nielsen, M. A. (2015). Neural Networks and Deep Learning.

Neurônio Simplificado

A diferença de Perceptron e Neurônio Artificaial

A Função de Ativação: O Divisor de Águas

Contexto Histórico e Evolutivo

Aplicações e Capacidades

Conclusão

Orientado a Objeto

Perceptron, Redes Neurais e Conceitos Fundamentais

O Perceptron: O Neurônio Artificial

O que é um Perceptron?

Estrutura Matemática

Limitações do Perceptron Simples

Redes Neurais: Conectando Perceptrons

Componentes Principais

Complexidade

O Poder das Camadas Ocultas

Arquitetura de Redes Neurais

Feedforward (Alimentação Direta)

Redes Recorrentes (RNN)

Convolucionais (CNN)

Parâmetros vs. Hiperparâmetros

Hiperparâmetros Fundamentais

Otimizador de Gradientes

Épocas (Epochs)

Taxa de Aprendizado (Learning Rate)

Tamanho do Lote (Batch Size)

Funções de Ativação

Funções de Custo (Loss Functions)

Backpropagation: O Coração do Aprendizado

O que é Backpropagation?

O Processo em Duas Fases

Regra da Cadeia na Prática

Por que é Eficiente?

Desafios

Fluxo Completo de Treinamento

Passo a Passo do Treinamento

Relação entre Todos os Componentes

Conclusão: A Sinergia dos Componentes

Referências e Leitura Adicional