Arquivo de Inteligência Artificial - Página 158 de 165

Rede Neural aprendendo lógica da tabela verdade AND

Recentemente desenvolvi uma implementação completa de uma rede neural perceptron capaz de aprender a porta lógica AND autonomamente.

Esta implementação demonstra conceitos fundamentais de machine learning através de um exemplo prático.

É importante observar que o problema da tabela verdade AND é um problema linear, por isso neste exercício não precisamos utilizar camadas ocultas.

Fundamentação Matemática

O perceptron opera com base na fórmula matemática:

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

Onde:

\(x_i\) representa as características de entrada
\(w_i\) denota os pesos correspondentes
\(b\) é o termo de bias
\(f\) é a função de ativação

Implementação Principal

A classe Neuronio encapsula toda a funcionalidade do perceptron. Primordialmente, ela inicializa com pesos aleatórios e progressivamente os ajusta através de iterações de treinamento.

Componentes Principais

A implementação inclui vários métodos essenciais:

soma(): Calcula a soma ponderada das entradas
funcaoAtivacao(): Implementa a função de ativação degrau
aprendeAtualiza(): Executa o algoritmo de aprendizado
testar(): Valida o modelo treinado

Algoritmo de Aprendizado

O processo de treinamento emprega uma abordagem de aprendizado supervisionado. Analogamente às redes neurais biológicas, o perceptron aprende através de correção de erro. A regra de atualização de pesos segue:

\(w_i^{novo} = w_i^{antigo} + \eta \times x_i \times erro\)

Onde \(\eta\) representa a taxa de aprendizado. Contudo, esta regra simples permite que a rede convirja para a solução correta.

Dinâmica do Treinamento

Durante o treinamento, o algoritmo itera através de épocas até que o erro total atinja zero. Inesperadamente, para o problema AND, a convergência tipicamente ocorre dentro de poucas iterações. Ademais, a taxa de aprendizado influencia significativamente a velocidade de convergência e estabilidade.

Propriedades Matemáticas

A função AND representa um problema linearmente separável. Conforme estabelecido na teoria do perceptron, isto garante convergência quando usando uma taxa de aprendizado apropriada. Todavia, problemas não linearmente separáveis requerem arquiteturas mais complexas.

Exemplo de Implementação em Python

Aqui está uma implementação refinada em Python demonstrando os conceitos principais:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Perceptron
from sklearn.metrics import accuracy_score

print("=" * 60)
print("IMPLEMENTAÇÃO DE PORTAS LÓGICAS COM PERCEPTRON")
print("=" * 60)

# Dados de entrada para portas lógicas (mesma estrutura do artigo)
# [A, B] onde A e B são entradas binárias
X = np.array([
    [0, 0],
    [0, 1], 
    [1, 0],
    [1, 1]
])

print("Dados de entrada (A, B):")
print(X)

# Definir os targets para diferentes portas lógicas
portas_logicas = {
    'AND': np.array([0, 0, 0, 1]),
    'OR': np.array([0, 1, 1, 1]),
    'NAND': np.array([1, 1, 1, 0]),
    'NOR': np.array([1, 0, 0, 0])
}

print(f"\n" + "=" * 50)
print("TREINAMENTO DO PERCEPTRON PARA CADA PORTA LÓGICA")
print("=" * 50)

resultados = {}

for porta, y in portas_logicas.items():
    print(f"\n🎯 TREINANDO PORTA {porta}:")
    print(f"Targets: {y}")
    
    # Criar e treinar o Perceptron
    perceptron = Perceptron(
        max_iter=1000,
        tol=1e-3,
        random_state=42,
        eta0=0.1,  # Taxa de aprendizado reduzida para melhor estabilidade
        shuffle=False  # Manter ordem dos dados para análise
    )
    
    # Treinar o modelo
    perceptron.fit(X, y)
    
    # Fazer previsões
    y_pred = perceptron.predict(X)
    accuracy = accuracy_score(y, y_pred)
    
    # Armazenar resultados
    resultados[porta] = {
        'modelo': perceptron,
        'previsoes': y_pred,
        'acuracia': accuracy,
        'pesos': perceptron.coef_[0],
        'bias': perceptron.intercept_[0],
        'iteracoes': perceptron.n_iter_
    }
    
    print(f"✅ Acurácia: {accuracy * 100}%")
    print(f"📊 Pesos aprendidos: {perceptron.coef_[0]}")
    print(f"🎯 Bias aprendido: {perceptron.intercept_[0]}")
    print(f"🔄 Iterações necessárias: {perceptron.n_iter_}")

# 💡 ANÁLISE DETALHADA DOS RESULTADOS
print(f"\n" + "=" * 50)
print("ANÁLISE COMPARATIVA DAS PORTAS LÓGICAS")
print("=" * 50)

print(f"\n{'Porta':<8} {'Acurácia':<10} {'Pesos':<20} {'Bias':<10} {'Iterações':<10}")
print("-" * 70)

for porta, info in resultados.items():
    pesos_str = f"[{info['pesos'][0]:.2f}, {info['pesos'][1]:.2f}]"
    print(f"{porta:<8} {info['acuracia']:<10.1%} {pesos_str:<20} {info['bias']:<10.2f} {info['iteracoes']:<10}")

# 🎨 VISUALIZAÇÃO DAS FRONTEIRAS DE DECISÃO
print(f"\n" + "=" * 50)
print("VISUALIZAÇÃO DAS FRONTEIRAS DE DECISÃO")
print("=" * 50)

plt.figure(figsize=(15, 12))

portas_visuais = ['AND', 'OR', 'NAND', 'NOR']
cores = ['red', 'blue', 'green', 'purple']

for i, porta in enumerate(portas_visuais):
    plt.subplot(2, 2, i+1)
    
    info = resultados[porta]
    modelo = info['modelo']
    
    # Criar mesh para plotar a fronteira de decisão
    x_min, x_max = -0.5, 1.5
    y_min, y_max = -0.5, 1.5
    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),
                         np.linspace(y_min, y_max, 100))
    
    # Prever para todos os pontos do mesh
    Z = modelo.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    
    # Plotar contorno da fronteira de decisão
    plt.contourf(xx, yy, Z, alpha=0.3, cmap='coolwarm')
    
    # Plotar pontos de dados
    scatter = plt.scatter(X[:, 0], X[:, 1], c=portas_logicas[porta], 
                         cmap='coolwarm', s=100, edgecolors='black')
    
    # Adicionar rótulos aos pontos
    for j, (x, y) in enumerate(X):
        plt.text(x, y + 0.05, f"{portas_logicas[porta][j]}", 
                ha='center', va='bottom', fontweight='bold')
    
    plt.xlabel('Entrada A')
    plt.ylabel('Entrada B')
    plt.title(f'Porta {porta}\nPesos: [{modelo.coef_[0][0]:.2f}, {modelo.coef_[0][1]:.2f}], Bias: {modelo.intercept_[0]:.2f}')
    plt.xlim(x_min, x_max)
    plt.ylim(y_min, y_max)
    plt.grid(True, alpha=0.3)
    
    # Adicionar equação da reta de decisão
    w1, w2 = modelo.coef_[0]
    b = modelo.intercept_[0]
    plt.text(0.5, -0.3, f'{w1:.2f}×A + {w2:.2f}×B + {b:.2f} = 0', 
             ha='center', va='center', 
             bbox=dict(boxstyle="round,pad=0.3", facecolor="yellow", alpha=0.7))

plt.tight_layout()
plt.show()

# 🔍 ANÁLISE DA PORTA XOR (NÃO LINEARMENTE SEPARÁVEL)
print(f"\n" + "=" * 50)
print("DESAFIO: PORTA XOR - NÃO LINEARMENTE SEPARÁVEL")
print("=" * 50)

# Dados para porta XOR
X_xor = X  # Mesmas entradas
y_xor = np.array([0, 1, 1, 0])  # XOR: 1 quando entradas são diferentes

print(f"Targets XOR: {y_xor}")

# Tentar treinar Perceptron para XOR
perceptron_xor = Perceptron(
    max_iter=1000,
    random_state=42
)

perceptron_xor.fit(X_xor, y_xor)
y_xor_pred = perceptron_xor.predict(X_xor)
accuracy_xor = accuracy_score(y_xor, y_xor_pred)

print(f"\nResultado para XOR:")
print(f"Acurácia: {accuracy_xor * 100}%")
print(f"Previsões: {y_xor_pred}")
print(f"Iterações: {perceptron_xor.n_iter_}")

if accuracy_xor < 1.0:
    print(f"❌ O Perceptron NÃO conseguiu aprender XOR!")
    print(f"   Isso demonstra a limitação de classificadores lineares simples.")
    print(f"   XOR requer uma fronteira de decisão não linear.")

# 💡 SOLUÇÃO: MULTI-LAYER PERCEPTRON (MLP) PARA XOR
print(f"\n" + "=" * 50)
print("SOLUÇÃO: REDE NEURAL MULTI-CAMADAS PARA XOR")
print("=" * 50)

from sklearn.neural_network import MLPClassifier

# Usar MLP com uma camada oculta para resolver XOR
mlp_xor = MLPClassifier(
    hidden_layer_sizes=(2,),  # Uma camada oculta com 2 neurônios
    activation='logistic',     # Função de ativação sigmoide
    max_iter=10000,
    random_state=42
)

mlp_xor.fit(X_xor, y_xor)
y_mlp_pred = mlp_xor.predict(X_xor)
accuracy_mlp = accuracy_score(y_xor, y_mlp_pred)

print(f"MLP para XOR:")
print(f"Acurácia: {accuracy_mlp * 100}%")
print(f"Previsões: {y_mlp_pred}")
print(f"Iterações: {mlp_xor.n_iter_}")
print(f"✅ MLP conseguiu aprender XOR!")

# 🎓 COMPARAÇÃO FINAL E LIÇÕES APRENDIDAS
print(f"\n" + "=" * 50)
print("LIÇÕES E CONCLUSÕES")
print("=" * 50)

print(f"\n📚 O QUE APRENDEMOS:")
print("1. ✅ Perceptron simples consegue aprender AND, OR, NAND, NOR")
print("2. ✅ A fronteira de decisão é sempre uma linha reta")
print("3. ❌ Perceptron NÃO consegue aprender XOR (problema não linear)")
print("4. ✅ Redes neurais multi-camadas resolvem problemas não lineares")
print("5. 🔧 Scikit-learn automatiza o processo de aprendizado")

print(f"\n🎯 COMPARAÇÃO COM IMPLEMENTAÇÃO MANUAL:")
print("• Artigo: Implementação manual com pesos fixos")
print("• Scikit-learn: Aprendizado automático dos pesos")
print("• Ambos demonstram os mesmos princípios fundamentais")

print(f"\n💡 APLICAÇÕES PRÁTICAS:")
print("• Sistemas de controle digital")
print("• Circuitos lógicos programáveis")
print("• Processamento de sinais binários")
print("• Fundamentos para redes neurais mais complexas")

# 📊 TABELA COMPARATIVA FINAL
print(f"\n" + "=" * 50)
print("TABELA COMPARATIVA FINAL")
print("=" * 50)

print(f"\n{'Porta':<8} {'Linear?':<10} {'Perceptron':<12} {'MLP':<8} {'Aplicação':<15}")
print("-" * 60)
print(f"{'AND':<8} {'Sim':<10} {'✅':<12} {'✅':<8} {'Controle':<15}")
print(f"{'OR':<8} {'Sim':<10} {'✅':<12} {'✅':<8} {'Seleção':<15}")
print(f"{'NAND':<8} {'Sim':<10} {'✅':<12} {'✅':<8} {'Negação':<15}")
print(f"{'NOR':<8} {'Sim':<10} {'✅':<12} {'✅':<8} {'Inibição':<15}")
print(f"{'XOR':<8} {'Não':<10} {'❌':<12} {'✅':<8} {'Comparação':<15}")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import Perceptron

from sklearn.metrics import accuracy_score

print("=" * 60)

print("IMPLEMENTAÇÃO DE PORTAS LÓGICAS COM PERCEPTRON")

print("=" * 60)

# Dados de entrada para portas lógicas (mesma estrutura do artigo)

# [A, B] onde A e B são entradas binárias

X = np.array([

[0, 0],

[0, 1],

[1, 0],

[1, 1]

])

print("Dados de entrada (A, B):")

print(X)

# Definir os targets para diferentes portas lógicas

portas_logicas = {

'AND': np.array([0, 0, 0, 1]),

'OR': np.array([0, 1, 1, 1]),

'NAND': np.array([1, 1, 1, 0]),

'NOR': np.array([1, 0, 0, 0])

}

print(f"\n" + "=" * 50)

print("TREINAMENTO DO PERCEPTRON PARA CADA PORTA LÓGICA")

print("=" * 50)

resultados = {}

for porta, y in portas_logicas.items():

print(f"\n🎯 TREINANDO PORTA {porta}:")

print(f"Targets: {y}")

# Criar e treinar o Perceptron

perceptron = Perceptron(

max_iter=1000,

tol=1e-3,

random_state=42,

eta0=0.1, # Taxa de aprendizado reduzida para melhor estabilidade

shuffle=False # Manter ordem dos dados para análise

)

# Treinar o modelo

perceptron.fit(X, y)

# Fazer previsões

y_pred = perceptron.predict(X)

accuracy = accuracy_score(y, y_pred)

# Armazenar resultados

resultados[porta] = {

'modelo': perceptron,

'previsoes': y_pred,

'acuracia': accuracy,

'pesos': perceptron.coef_[0],

'bias': perceptron.intercept_[0],

'iteracoes': perceptron.n_iter_

}

print(f"✅ Acurácia: {accuracy * 100}%")

print(f"📊 Pesos aprendidos: {perceptron.coef_[0]}")

print(f"🎯 Bias aprendido: {perceptron.intercept_[0]}")

print(f"🔄 Iterações necessárias: {perceptron.n_iter_}")

# 💡 ANÁLISE DETALHADA DOS RESULTADOS

print(f"\n" + "=" * 50)

print("ANÁLISE COMPARATIVA DAS PORTAS LÓGICAS")

print("=" * 50)

print(f"\n{'Porta':<8} {'Acurácia':<10} {'Pesos':<20} {'Bias':<10} {'Iterações':<10}")

print("-" * 70)

for porta, info in resultados.items():

pesos_str = f"[{info['pesos'][0]:.2f}, {info['pesos'][1]:.2f}]"

print(f"{porta:<8} {info['acuracia']:<10.1%} {pesos_str:<20} {info['bias']:<10.2f} {info['iteracoes']:<10}")

# 🎨 VISUALIZAÇÃO DAS FRONTEIRAS DE DECISÃO

print(f"\n" + "=" * 50)

print("VISUALIZAÇÃO DAS FRONTEIRAS DE DECISÃO")

print("=" * 50)

plt.figure(figsize=(15, 12))

portas_visuais = ['AND', 'OR', 'NAND', 'NOR']

cores = ['red', 'blue', 'green', 'purple']

for i, porta in enumerate(portas_visuais):

plt.subplot(2, 2, i+1)

info = resultados[porta]

modelo = info['modelo']

# Criar mesh para plotar a fronteira de decisão

x_min, x_max = -0.5, 1.5

y_min, y_max = -0.5, 1.5

xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),

np.linspace(y_min, y_max, 100))

# Prever para todos os pontos do mesh

Z = modelo.predict(np.c_[xx.ravel(), yy.ravel()])

Z = Z.reshape(xx.shape)

# Plotar contorno da fronteira de decisão

plt.contourf(xx, yy, Z, alpha=0.3, cmap='coolwarm')

# Plotar pontos de dados

scatter = plt.scatter(X[:, 0], X[:, 1], c=portas_logicas[porta],

cmap='coolwarm', s=100, edgecolors='black')

# Adicionar rótulos aos pontos

for j, (x, y) in enumerate(X):

plt.text(x, y + 0.05, f"{portas_logicas[porta][j]}",

ha='center', va='bottom', fontweight='bold')

plt.xlabel('Entrada A')

plt.ylabel('Entrada B')

plt.title(f'Porta {porta}\nPesos: [{modelo.coef_[0][0]:.2f}, {modelo.coef_[0][1]:.2f}], Bias: {modelo.intercept_[0]:.2f}')

plt.xlim(x_min, x_max)

plt.ylim(y_min, y_max)

plt.grid(True, alpha=0.3)

# Adicionar equação da reta de decisão

w1, w2 = modelo.coef_[0]

b = modelo.intercept_[0]

plt.text(0.5, -0.3, f'{w1:.2f}×A + {w2:.2f}×B + {b:.2f} = 0',

ha='center', va='center',

bbox=dict(boxstyle="round,pad=0.3", facecolor="yellow", alpha=0.7))

plt.tight_layout()

plt.show()

# 🔍 ANÁLISE DA PORTA XOR (NÃO LINEARMENTE SEPARÁVEL)

print(f"\n" + "=" * 50)

print("DESAFIO: PORTA XOR - NÃO LINEARMENTE SEPARÁVEL")

print("=" * 50)

# Dados para porta XOR

X_xor = X # Mesmas entradas

y_xor = np.array([0, 1, 1, 0]) # XOR: 1 quando entradas são diferentes

print(f"Targets XOR: {y_xor}")

# Tentar treinar Perceptron para XOR

perceptron_xor = Perceptron(

max_iter=1000,

random_state=42

)

perceptron_xor.fit(X_xor, y_xor)

y_xor_pred = perceptron_xor.predict(X_xor)

accuracy_xor = accuracy_score(y_xor, y_xor_pred)

print(f"\nResultado para XOR:")

print(f"Acurácia: {accuracy_xor * 100}%")

print(f"Previsões: {y_xor_pred}")

print(f"Iterações: {perceptron_xor.n_iter_}")

if accuracy_xor < 1.0:

print(f"❌ O Perceptron NÃO conseguiu aprender XOR!")

print(f" Isso demonstra a limitação de classificadores lineares simples.")

print(f" XOR requer uma fronteira de decisão não linear.")

# 💡 SOLUÇÃO: MULTI-LAYER PERCEPTRON (MLP) PARA XOR

print(f"\n" + "=" * 50)

print("SOLUÇÃO: REDE NEURAL MULTI-CAMADAS PARA XOR")

print("=" * 50)

from sklearn.neural_network import MLPClassifier

# Usar MLP com uma camada oculta para resolver XOR

mlp_xor = MLPClassifier(

hidden_layer_sizes=(2,), # Uma camada oculta com 2 neurônios

activation='logistic', # Função de ativação sigmoide

max_iter=10000,

random_state=42

)

mlp_xor.fit(X_xor, y_xor)

y_mlp_pred = mlp_xor.predict(X_xor)

accuracy_mlp = accuracy_score(y_xor, y_mlp_pred)

print(f"MLP para XOR:")

print(f"Acurácia: {accuracy_mlp * 100}%")

print(f"Previsões: {y_mlp_pred}")

print(f"Iterações: {mlp_xor.n_iter_}")

print(f"✅ MLP conseguiu aprender XOR!")

# 🎓 COMPARAÇÃO FINAL E LIÇÕES APRENDIDAS

print(f"\n" + "=" * 50)

print("LIÇÕES E CONCLUSÕES")

print("=" * 50)

print(f"\n📚 O QUE APRENDEMOS:")

print("1. ✅ Perceptron simples consegue aprender AND, OR, NAND, NOR")

print("2. ✅ A fronteira de decisão é sempre uma linha reta")

print("3. ❌ Perceptron NÃO consegue aprender XOR (problema não linear)")

print("4. ✅ Redes neurais multi-camadas resolvem problemas não lineares")

print("5. 🔧 Scikit-learn automatiza o processo de aprendizado")

print(f"\n🎯 COMPARAÇÃO COM IMPLEMENTAÇÃO MANUAL:")

print("• Artigo: Implementação manual com pesos fixos")

print("• Scikit-learn: Aprendizado automático dos pesos")

print("• Ambos demonstram os mesmos princípios fundamentais")

print(f"\n💡 APLICAÇÕES PRÁTICAS:")

print("• Sistemas de controle digital")

print("• Circuitos lógicos programáveis")

print("• Processamento de sinais binários")

print("• Fundamentos para redes neurais mais complexas")

# 📊 TABELA COMPARATIVA FINAL

print(f"\n" + "=" * 50)

print("TABELA COMPARATIVA FINAL")

print("=" * 50)

print(f"\n{'Porta':<8} {'Linear?':<10} {'Perceptron':<12} {'MLP':<8} {'Aplicação':<15}")

print("-" * 60)

print(f"{'AND':<8} {'Sim':<10} {'✅':<12} {'✅':<8} {'Controle':<15}")

print(f"{'OR':<8} {'Sim':<10} {'✅':<12} {'✅':<8} {'Seleção':<15}")

print(f"{'NAND':<8} {'Sim':<10} {'✅':<12} {'✅':<8} {'Negação':<15}")

print(f"{'NOR':<8} {'Sim':<10} {'✅':<12} {'✅':<8} {'Inibição':<15}")

print(f"{'XOR':<8} {'Não':<10} {'❌':<12} {'✅':<8} {'Comparação':<15}")

Pontos de Conexão com o Artigo Original

Estrutura de dados idêntica: Mesmas entradas [A, B] e saídas binárias
Portas lógicas equivalentes: AND, OR, NAND, NOR com mesma semântica
Fundamentos matemáticos compartilhados: Função de ativação degrau e combinação linear
Limitação: : XOR por ser não-linear

Valor Adicional da Abordagem Scikit-Learn

Ocasionalmente, implementações manuais podem ser educativas mas impráticas para problemas complexos. Contudo, o scikit-learn oferece vantagens significativas:

Automatização do aprendizado: Não requer ajuste manual de pesos
Otimização robusta: Algoritmos de convergência testados
Escalabilidade: Funciona com datasets maiores
Integração com ecossistema: Compatível com outras ferramentas de ML

Considerações Finais

Esta implementação demonstra elegantemente os princípios fundamentais das redes neurais. Similarmente a sistemas biológicos, o perceptron aprende através de ajustes incrementais baseados em erro. Eventualmente, esta abordagem forma a base para arquiteturas mais complexas de deep learning.

Principalmente, é importante notar que enquanto o perceptron resolve problemas linearmente separáveis de forma eficiente, problemas mais complexos requerem redes multicamadas. Inclusive, a adição de camadas ocultas e funções de ativação não-lineares permite resolver problemas não linearmente separáveis.

Portanto, esta implementação serve como uma fundação sólida para compreender mecanismos mais avançados de aprendizado de máquina. Afinal, o entendimento profundo destes conceitos básicos é essencial para o domínio de técnicas mais sofisticadas.

Framework de Machine Learning: Especialidades e Aplicações

TensorFlow: O Ecossistema Completo

PyTorch: A Revolução da Pesquisa

Scikit-learn: A Base do ML Tradicional

JAX: O Paradigma da Computação Científica

Diferenças Fundamentais e Aplicações

Casos de Uso Recomendados

TensorFlow

PyTorch

Scikit-learn

JAX

Modelos Lineares Generalizados: Perceptron

Rede Neural aprendendo lógica da tabela verdade AND

Fundamentação Matemática

Implementação Principal

Componentes Principais

Algoritmo de Aprendizado

Dinâmica do Treinamento

Propriedades Matemáticas

Exemplo de Implementação em Python

Pontos de Conexão com o Artigo Original

Valor Adicional da Abordagem Scikit-Learn

Considerações Finais