Arquivo de Python - Página 63 de 94

Neurônio Simplificado

19/12/202512/10/2025 Por antonino

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

"""

TensorFlow na prática: modelos prontos que resolvem problemas reais

19/12/202525/09/2025 Por antonino

Quando construir do zero não é a opção mais inteligente

Você já passou horas tentando construir uma rede neural do zero para classificar imagens, apenas para descobrir que alguém já resolveu esse problema de forma muito mais eficiente? Esta frustração comum é exatamente o motivo pelo qual o TensorFlow oferece modelos pré-treinados – soluções sofisticadas que você pode usar imediatamente, economizando semanas de trabalho e recursos computacionais valiosos.

Como os modelos pré-treinados aceleram seu projeto

Imagine ter acesso a redes neurais que já aprenderam a reconhecer padrões em milhões de imagens, textos ou sons. O TensorFlow Hub e Keras Applications fornecem exatamente isso – modelos que já dominaram tarefas complexas e podem ser adaptados para seus problemas específicos através do transfer learning. Esta abordagem permite que você alcance resultados profissionais mesmo com datasets pequenos e hardware limitado.

Do conceito à aplicação em minutos

"""
Classificação de imagens com modelos pré-treinados do TensorFlow
Resolvendo problemas reais sem construir redes do zero
"""
import tensorflow as tf
import tensorflow_hub as hub
import numpy as np
from PIL import Image
import requests
from io import BytesIO

print("🖼️ CLASSIFICAÇÃO DE IMAGENS COM MOBILENET")
print("=" * 50)

# Carregando modelo pré-treinado do TensorFlow Hub
model_url = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/classification/4"
modelo = tf.keras.Sequential([
    hub.KerasLayer(model_url, input_shape=(224, 224, 3))
])

print("✅ Modelo MobileNet carregado com sucesso!")
print(f"📊 Modelo pronto para classificar entre 1000 categorias")

# Função para pré-processar imagem
def preparar_imagem(url_imagem):
    response = requests.get(url_imagem)
    img = Image.open(BytesIO(response.content))
    img = img.resize((224, 224))
    img_array = np.array(img) / 255.0
    img_array = np.expand_dims(img_array, axis=0)
    return img_array

# Exemplo: classificando imagem de um cachorro
url_cachorro = "https://images.unsplash.com/photo-1552053831-71594a27632d?w=400"
imagem_preparada = preparar_imagem(url_cachorro)

# Fazendo a previsão
previsoes = modelo.predict(imagem_preparada)
classe_predita = np.argmax(previsoes[0])

print(f"🎯 Classe predita: {classe_predita}")
print("💡 Dica: Use ImageNet labels para traduzir o número para categoria")

# Carregando labels do ImageNet
labels_url = "https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt"
response = requests.get(labels_url)
labels = response.text.split('\n')[1:]  # Pula o header

if classe_predita < len(labels):
    print(f"📝 Categoria: {labels[classe_predita]}")

"""

Classificação de imagens com modelos pré-treinados do TensorFlow

Resolvendo problemas reais sem construir redes do zero

"""

import tensorflow as tf

import tensorflow_hub as hub

import numpy as np

from PIL import Image

import requests

from io import BytesIO

print("🖼️ CLASSIFICAÇÃO DE IMAGENS COM MOBILENET")

print("=" * 50)

# Carregando modelo pré-treinado do TensorFlow Hub

model_url = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/classification/4"

modelo = tf.keras.Sequential([

hub.KerasLayer(model_url, input_shape=(224, 224, 3))

])

print("✅ Modelo MobileNet carregado com sucesso!")

print(f"📊 Modelo pronto para classificar entre 1000 categorias")

# Função para pré-processar imagem

def preparar_imagem(url_imagem):

response = requests.get(url_imagem)

img = Image.open(BytesIO(response.content))

img = img.resize((224, 224))

img_array = np.array(img) / 255.0

img_array = np.expand_dims(img_array, axis=0)

return img_array

# Exemplo: classificando imagem de um cachorro

url_cachorro = "https://images.unsplash.com/photo-1552053831-71594a27632d?w=400"

imagem_preparada = preparar_imagem(url_cachorro)

# Fazendo a previsão

previsoes = modelo.predict(imagem_preparada)

classe_predita = np.argmax(previsoes[0])

print(f"🎯 Classe predita: {classe_predita}")

print("💡 Dica: Use ImageNet labels para traduzir o número para categoria")

# Carregando labels do ImageNet

labels_url = "https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt"

response = requests.get(labels_url)

labels = response.text.split('\n')[1:] # Pula o header

if classe_predita < len(labels):

print(f"📝 Categoria: {labels[classe_predita]}")

Por que o transfer learning é um superpoder

Os modelos pré-treinados capturaram padrões fundamentais que são transferíveis entre diferentes domínios. Um modelo treinado para reconhecer objetos em fotos gerais, por exemplo, já aprendeu a detectar bordas, texturas e formas – conhecimento que é extremamente valioso para tarefas específicas como identificar doenças em raios-X ou analisar imagens de satélite. Esta reutilização inteligente do conhecimento é o que torna o deep learning acessível para projetos do mundo real.

Escolhendo o modelo certo para seu problema

MobileNet: perfeito para aplicações móveis e edge devices
ResNet: excelente balance entre acurácia e performance
EfficientNet: estado da arte em eficiência computacional
BERT: padrão ouro para processamento de linguagem natural
YOLO: detecção de objetos em tempo real

Perguntas que todo praticante de TensorFlow enfrenta

Você deve estar se perguntando: “Quando devo usar um modelo pré-treinado em vez de construir meu próprio?” A resposta é simples: quase sempre! Uma confusão comum é achar que modelos personalizados são necessariamente melhores – na realidade, modelos pré-treinados oferecem desempenho superior na maioria dos casos. Outra dúvida frequente: “Como adaptar um modelo genérico para meu problema específico?” Através do fine-tuning, onde você substitui as camadas finais e treina apenas parte da rede com seus dados.

Armadilhas comuns ao usar modelos pré-treinados

Pré-processamento incorreto: cada modelo exige normalização específica
Domínio muito diferente: modelos de imagens médicas vs. imagens gerais
Overfitting no fine-tuning: muito treinamento em poucos dados
Problemas de licença: verificar restrições de uso comercial
Tamanho do modelo: considerar limitações de hardware de produção

O momento “aha!” da eficiência computacional

Quando você descobre que pode alcançar 95% de acurácia com um modelo que treina em minutos em vez de semanas, toda sua perspectiva sobre deep learning se transforma. De repente, projetos que pareciam impossíveis tornam-se viáveis. Esta eficiência não é apenas sobre economizar tempo – é sobre possibilitar experimentação e iteração rápida, que são essenciais para desenvolver soluções robustas.

Fine-tuning na prática: customizando para seu domínio

"""
Fine-tuning de modelo pré-treinado para classificação customizada
Adaptando um modelo genérico para seu problema específico
"""
import tensorflow as tf
from tensorflow import keras

print("🎨 FINE-TUNING PARA CLASSIFICAÇÃO CUSTOMIZADA")
print("=" * 50)

# Carregando base do MobileNet sem as camadas superiores
base_model = keras.applications.MobileNetV2(
    weights='imagenet',
    include_top=False,
    input_shape=(224, 224, 3)
)

# Congelando as camadas base (não treináveis)
base_model.trainable = False

# Adicionando novas camadas para nossa tarefa específica
modelo_customizado = keras.Sequential([
    base_model,
    keras.layers.GlobalAveragePooling2D(),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(5, activation='softmax')  # 5 classes personalizadas
])

print("📋 Arquitetura do modelo customizado:")
modelo_customizado.summary()

# Compilando o modelo
modelo_customizado.compile(
    optimizer='adam',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

print("✅ Modelo pronto para fine-tuning com seus dados!")
print("💡 Dica: Descongele algumas camadas base para treinamento posterior")

"""

Fine-tuning de modelo pré-treinado para classificação customizada

Adaptando um modelo genérico para seu problema específico

"""

import tensorflow as tf

from tensorflow import keras

print("🎨 FINE-TUNING PARA CLASSIFICAÇÃO CUSTOMIZADA")

print("=" * 50)

# Carregando base do MobileNet sem as camadas superiores

base_model = keras.applications.MobileNetV2(

weights='imagenet',

include_top=False,

input_shape=(224, 224, 3)

)

# Congelando as camadas base (não treináveis)

base_model.trainable = False

# Adicionando novas camadas para nossa tarefa específica

modelo_customizado = keras.Sequential([

base_model,

keras.layers.GlobalAveragePooling2D(),

keras.layers.Dense(128, activation='relu'),

keras.layers.Dropout(0.2),

keras.layers.Dense(5, activation='softmax') # 5 classes personalizadas

])

print("📋 Arquitetura do modelo customizado:")

modelo_customizado.summary()

# Compilando o modelo

modelo_customizado.compile(

optimizer='adam',

loss='categorical_crossentropy',

metrics=['accuracy']

)

print("✅ Modelo pronto para fine-tuning com seus dados!")

print("💡 Dica: Descongele algumas camadas base para treinamento posterior")

Transformando conhecimento em aplicações reais

Comece experimentando com modelos pré-treinados em problemas simples para desenvolver familiaridade com o fluxo de trabalho. Posteriormente, avance para fine-tuning em datasets específicos do seu domínio. Finalmente, explore técnicas avançadas como ensemble de modelos e otimização para produção – estas habilidades diferenciam profissionais juniores de experts em machine learning engineering.

Próximos passos para dominar TensorFlow

Experimente diferentes arquiteturas: compare performance entre modelos
Domine o TensorFlow Serving: aprenda a colocar modelos em produção
Explore TensorFlow Lite: otimize para dispositivos móveis
Aprenda TensorFlow.js: execute modelos no navegador
Pratique transfer learning: adapte modelos para domínios específicos

Recursos para acelerar sua jornada

Estas referências oferecem desde exemplos básicos até implementações avançadas, permitindo que você evolua rapidamente no ecossistema TensorFlow.

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

Quando construir do zero não é a opção mais inteligente

Como os modelos pré-treinados aceleram seu projeto

Do conceito à aplicação em minutos

Por que o transfer learning é um superpoder

Escolhendo o modelo certo para seu problema

Perguntas que todo praticante de TensorFlow enfrenta

Armadilhas comuns ao usar modelos pré-treinados

O momento “aha!” da eficiência computacional

Fine-tuning na prática: customizando para seu domínio

Transformando conhecimento em aplicações reais

Próximos passos para dominar TensorFlow

Recursos para acelerar sua jornada

Links que valem seu tempo