<jupyter_start><jupyter_text>Fazendo um percepton de uma camada usando lowlevel api:  Utilizaremos a tabela verdade de um AND:<jupyter_code>import numpy as np
X = np.array([[0.0, 0.0],
              [0.0, 1.0],
              [1.0, 0.0],
              [1.0, 1.0]])
X
y = np.array([[0.0], [0.0], [0.0], [1.0]])
y
W= np.array([[0.0],[0.0]])
W
def step(x):
    return float(x>=1)
camada_saida=np.matmul(X,W)
camada_saida
camada_de_saida_ativacao=np.array(list(map(step,camada_saida)))

camada_de_saida_ativacao=np.array([camada_de_saida_ativacao]).T  #transpondo o vetor linha para coluna

camada_de_saida_ativacao
erro = y-camada_de_saida_ativacao
erro
delta = np.matmul(X.T,erro)
delta
W=W+(0.1*delta)
W
erro_soma = np.sum(erro)
erro_soma<jupyter_output><empty_output><jupyter_text>Fazendo a recorrencia do modelo:<jupyter_code>del erro_soma, delta, camada_saida, erro, camada_de_saida_ativacao 
#limpando as variaveis
#rode as 3 celulas iniciais setando X, Y e W, antes de rodar a celula abaixo
epoca = 0
for i in range(20):
    epoca += 1
    
    camada_saida=np.matmul(X,W)
    
    camada_de_saida_ativacao=np.array(list(map(step,camada_saida)))
    camada_de_saida_ativacao=np.array([camada_de_saida_ativacao]).T  #transpondo o vetor linha para coluna
    
    erro = y-camada_de_saida_ativacao
    erro_soma = np.sum(erro)

    delta = np.matmul(X.T,erro)
    
    W=W+(0.1*delta)
        
    print('Época:', epoca, ' Erro: ', erro_soma)
    if erro_soma == 0.0:
        break<jupyter_output>Época: 1  Erro:  1.0
Época: 2  Erro:  1.0
Época: 3  Erro:  1.0
Época: 4  Erro:  1.0
Época: 5  Erro:  0.0<jupyter_text>Fazendo um percepton com camada oculta: (lowlevel)  Utilizaremos a tabela verdade da XOR:Esse é um tipico problema linearmente não separavel<jupyter_code>import random
from sklearn.metrics import mean_squared_error


X = np.array([[0.0, 0.0],
              [0.0, 1.0],
              [1.0, 0.0],
              [1.0, 1.0]])
X
y = np.array([[1.0], [0.0], [0.0], [1.0]])
y
neuronios_entrada = 2
neuronios_oculta = 3
neuronios_saida = 1
random.uniform(0,1)
def cria_matriz_random(linha, coluna):
    lista_aux=[]
    for i in range(linha):
        for j in range(coluna):
            lista_aux.append(random.uniform(0,1))

    lista_aux=np.asarray(lista_aux)
    return lista_aux.reshape(linha, coluna)<jupyter_output><empty_output><jupyter_text>Criei a funçao acima para facilitar na implementação dos dicionarios.<jupyter_code>W = {'oculta': cria_matriz_random(neuronios_entrada,neuronios_oculta), 
     'saida': cria_matriz_random(neuronios_oculta,neuronios_saida)}
#basicamente esse é o dicionario com os pesos da rede
W
b= {'oculta': cria_matriz_random(1,neuronios_oculta),
    'saida': cria_matriz_random(1,neuronios_saida)}
#basicamente esse é o dicionario com os pesos das Bias
b<jupyter_output><empty_output><jupyter_text>Iremos utilizar a função sigmoide para ativação do neuronio.<jupyter_code>def sigmoid(x):
    return 1 / (1 + np.exp(-x))
#estamos calculando a saida através da entrada passando pelos pesos e ativaçao
taxa_aprendizagem=0.2

for i in range(1000):
    camada_oculta=np.matmul(X,W['oculta'])+b['oculta'] 
    camada_oculta_ativacao=sigmoid(camada_oculta)

    camada_saida=np.matmul(camada_oculta_ativacao,W['saida'])+b['saida']
    camada_saida_ativacao=sigmoid(camada_saida)

    erro=mean_squared_error(y, camada_saida_ativacao)

    #implementacao do backpropagantion
    #atualizando os pesos
    W['saida']=np.matmul(camada_oculta.T, camada_saida_ativacao)*taxa_aprendizagem*erro
    W['oculta']=np.matmul(X.T,camada_oculta_ativacao)*taxa_aprendizagem*erro
    #print('Erro:',erro)
    #print('Saidas:',camada_saida_ativacao)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12378378378378378, 'fraction_numerical': 0.025945945945945945, 'mean_word_length': 4.49925705794948, 'pattern_counts': {'":': 0, '<': 20, '<?xml version=': 0, '>': 21, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '5', 'dir': 'jupyter-structured-clean-dedup', 'id': '642310', 'license': 'Apache-2.0', 'n_tokens_mistral': 1663, 'n_tokens_neox': 1632, 'n_words': 294, 'path': 'Udemy/Percepton/Rede_neural_lowlevel.ipynb', 'repo_name': 'peddrogomes/Playground', 'size': '3700'}