import numpy as np

# Entradas (ex: 2 features)
x = np.array([0.5, 0.3])

# Pesos (força das conexões)
w = np.array([0.8, 0.2])

# Bias
b = 0.1

# Soma ponderada + bias
z = np.dot(x, w) + b

# Função de ativação (sigmoid)
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

saida = sigmoid(z)
print(f"Soma ponderada: {z:.4f}")
print(f"Saída (sigmoid): {saida:.4f}")

import numpy as np

# ---------------------------
# Dados de entrada
# ---------------------------

X = np.array([
    [0.9, 0.8], # Boa nota, boa frequência -> Aprovado
    [0.7, 0.6], # Nota ok, frequência ok -> Aprovado
    [0.2, 0.3], # Nota ruim, frequência ruim -> Reprovado
    [0.1, 0.4]  # Nota muito ruim, frequência ruim -> Reprovado
])

# Resultados esperados (1 = Aprovado, 0 = Reprovado)
y = np.array([1,1,0,0])

# ---------------------------
# Inicializando pesos
# ---------------------------

np.random.seed(1) # Para resultados reproduzíveis

w = np.random.rand(2) # Pesos para nota e frequência
b = np.random.rand()  # Bias inicial

# Taxa de aprendizado: controla o tamanho dos ajustes
lr = 0.1

# ---------------------------
# Função sigmoid
# ---------------------------

def sigmoid(z):
    return 1/(1+np.exp(-z))

# ---------------------------
# Treinamento
# ---------------------------

for epoch in range(20): # Número de "rodadas" de aprendizado

    print(f"\nEpoch {epoch}")

    for i in range(len(X)): # Itera sobre cada estudante

        x = X[i] # Entradas do estudante atual

        # Soma ponderada (influência das entradas + bias)
        z = np.dot(x,w) + b

        # Saída do neurônio (predição)
        pred = sigmoid(z)

        # Erro: quanto erramos na previsão?
        error = y[i] - pred

        # Ajuste dos pesos e bias (o "aprendizado")
        w += lr * error * x
        b += lr * error

        print("Entrada:",x)
        print("Predição:",round(pred,3))
        print("Erro:",round(error,3))

print("\n---------------------------")
print("Pesos finais:",np.round(w, 3))
print("Bias final:",round(b, 3))
print("---------------------------")

import numpy as np

# Definindo os parâmetros do neurônio
pesos = np.array([2.0, 1.0])  # Importância de cada entrada
bias = -2.5

# Função de Ativação (Step Function)
# Produz 1 se a soma ponderada + bias for >= 0, senão 0
def funcao_ativacao_degrau(z):
    return 1 if z >= 0 else 0

# Diferentes conjuntos de entradas para teste
conjuntos_de_entrada = [
    np.array([0.5, 0.5]),  # Exemplo 1: ambas baixas
    np.array([1.0, 0.5]),  # Exemplo 2: uma média, outra baixa
    np.array([0.0, 1.0]),  # Exemplo 3: uma zero, outra média
    np.array([1.5, 1.5])   # Exemplo 4: ambas altas
]

print("--- Simulação de Decisão do Neurônio ---")
for i, x in enumerate(conjuntos_de_entrada):
    # 1. Soma Ponderada + Bias
    valor_liquido = np.dot(x, pesos) + bias
    
    # 2. Aplicar Função de Ativação
    saida_do_neuronio = funcao_ativacao_degrau(valor_liquido)
    
    print(f"Entrada {i+1} ({x}):")
    print(f"  Soma Ponderada + Bias: {valor_liquido:.2f}")
    print(f"  Saída do Neurônio: {saida_do_neuronio}")
    print("--------------------------------------")