- Perceptron de Uma Camada – Modelo Simples

base.exibe_em_tela ()

 

Por fim, testando nosso método exclui_elemento( ) será possível ver que quando excluímos um determinado elemento do vetor, os elementos subsequentes serão realocados automaticamente para que as posições de índice se mantenham íntegras.

Nesse caso, o retorno será:

0 9

1 3

2 1

3 4

4 5

5 20

 

- Perceptron de Uma Camada – Modelo Simples

Inicialmente vamos fazer a codificação do algoritmo de um

Perceptron, estrutura de dado utilizada em machine learning para abstrair uma rede neural biológica para rede neural artificial.

Sendo assim, pondo em prática o mesmo, através do Google

Colaboratory (sinta-se livre para usar o Colaboratory ou o Jupyter da suíte Anaconda), ferramentas que nos permitirão tanto criar este perceptron quanto o executar em simultâneo. Posteriormente em problemas que denotarão maior complexidade estaremos usando outras ferramentas.

Abrindo nosso Colaboratory inicialmente renomeamos nosso

notebook para Perceptron 1 Camada.ipynb apenas por convenção. *Ao criar um notebook Python 3 em seu Colaboratory automaticamente será criada uma pasta em seu Drive de nome Colab Notebooks, onde será salva uma cópia deste arquivo para posterior utilização.

Por parte de código apenas foi criado na primeira célula um

comentário, na segunda célula foram declaradas duas variáveis de nomes entradas e pesos, respectivamente. Como estamos atribuindo vários valores para cada uma passamos esses valores em forma de lista, pela sintaxe Python, entre chaves e separados por vírgula.

Aqui estamos usando os mesmos valores usados no modelo de

perceptron anteriormente descrito, logo, entradas recebe os valores 1, 9 e 5 referentes aos nós de entrada X, Y e Z de nosso modelo assim como pesos recebe os valores 0.8, 0.1 e 0 como no modelo.

 

Em seguida criamos uma função de nome soma que recebe como

parâmetro as variáveis temporárias e e p. Dentro dessa função inicialmente criamos uma nova variável de nome s que inicializa com valor 0. Em seguida criamos um laço de repetição que irá percorrer todos valores de e e p, realizar a sua multiplicação e atribuir esse valor a variável s. Por fim apenas deixamos um comando para retornar s, agora com valor atualizado.

 

Criamos uma variável de nome s que recebe como atributo a

função soma, passando como parâmetro as variáveis entradas e pesos. Executando uma função print( ) passando como parâmetro a variável s finalmente podemos ver que foram feitas as devidas operações sobre as variáveis, retornando o valor de 1.7, confirmando o modelo anterior.

 

Assim como criamos a função de soma entre nossas entradas e seus

respectivos pesos, o processo final desse perceptron é a criação de nossa função degrau. Função essa que simplesmente irá pegar o valor retornado de soma e estimar com base nesse valor se esse neurônio será ativado ou não.

Para isso simplesmente criamos outra função, agora de nome

stepFunction( ) que recebe como parâmetro s. Dentro da função simplesmente criamos uma estrutura condicional onde, se o valor de s for igual ou maior que 1, retornará 1 (referência para ativação), caso contrário, retornará 0 (referência para não ativação).

Em seguida criamos uma variável de nome saida que recebe como

atributo a função stepFunction( ) que por sua vez tem como parâmetro s. Por fim executamos uma função print( ) agora com saida como parâmetro, retornando finalmente o valor 1, resultando como previsto, na ativação deste perceptron.

 

Código Completo:

 

Aprimorando o Código:

Como mencionado nos capítulos iniciais, uma das particularidades

por qual escolhemos desenvolver nossos códigos em Python é a questão de termos diversas bibliotecas, módulos e extensões que irão facilitar nossa vida oferecendo ferramentas que não só automatizam, mas melhoram processos no que diz respeito a performance.

Não existe problema algum em mantermos o código acima usando

apenas os recursos do interpretador do Python, porém se podemos realizar a mesma tarefa de forma mais reduzida e com maior performance por quê não o fazer.

Sendo assim, usaremos aplicado ao exemplo atual alguns recursos da biblioteca Numpy, de forma a usar seus recursos internos para tornar nosso código mais enxuto e eficiente. Aqui trabalharemos pressupondo que você já instalou tal biblioteca como foi orientado em um capítulo anterior.

 

Sempre que formos trabalhar com bibliotecas que nativamente não

são carregadas e pré-alocadas por nossa IDE precisamos fazer a importação das mesmas. No caso da Numpy, uma vez que essa já está instalada no sistema, basta executarmos o código import numpy para que a mesma seja carregada e possamos usufruir de seus recursos.

Por convenção quando importamos alguns tipos de biblioteca ou

módulos podemos as referenciar por alguma abreviação, simplesmente para facilitar sua chamada durante o código. Logo, o comando import numpy as np importa a biblioteca Numpy e sempre que a formos usar basta iniciar o código com np.

 

Da mesma forma que fizemos anteriormente, criamos duas

variáveis que recebem os respectivos valores de entradas e pesos. Porém, note a primeira grande diferença de código, agora não passamos uma simples lista de valores, agora criamos uma array Numpy para que esses dados sejam vetorizados e trabalhados internamente pelo Numpy. Ao usarmos o comando np.array( ) estamos criando um vetor ou matriz, dependendo da situação, para que as ferramentas internas desta biblioteca possam trabalhar com os mesmos.

 

Segunda grande diferença agora é dada em nossa função de Soma,

repare que agora ela simplesmente contém como parâmetros e e p, e ela executa uma única linha de função onde ela retornará o produto escalar de e sobre p. Em outras palavras, o comando e.dot(p) fará o mesmo processo aritmético que fizemos manualmente, de realizar as multiplicações e somas dos valores de e com p, porém de forma muito mais eficiente.

 

Todo o resto do código é reaproveitado e executado da mesma

forma, obtendo inclusive como retorno os mesmos resultados (o que é esperado), a diferença de trocar uma função básica, baseada em listas e condicionais, por um produto escalar realizado por módulo de uma biblioteca dedicada a isto torna o processo mais eficiente.

Raciocine que à medida que formos implementando mais linhas de

código com mais funções essas pequenas diferenças de performance realmente irão impactar o desempenho de nosso código final.

 

Código Completo:

Usando o Spyder 3:

Os códigos apresentados anteriormente foram rodados diretamente

no notebook Colab do Google, porém haverão situações de código mais complexo onde não iremos conseguir executar os códigos normalmente a partir de um notebook.

Outra ferramenta bastante usada para manipulação de dados em

geral é o Spyder. Dentro dele podemos criar e executar os mesmos códigos de uma forma um pouco diferente graças aos seus recursos.

Por hora, apenas entenda que será normal você ter de se

familiarizar com diferentes ferramentas uma vez que algumas situações irão requerer mais ferramentas específicas.

Tratando-se do Spyder, este será o IDE que usaremos para

praticamente tudo a partir daqui, graças a versatilidade de por meio dele podermos escrever nossas linhas de código, executá-las individualmente e em tempo real e visualizar os dados de forma mais intuitiva.

Abrindo o Spyder diretamente pelo seu atalho ou por meio da suíte

 

Anaconda nos deparamos com sua tela inicial, basicamente o Spyder já vem pré-configurado de forma que possamos simplesmente nos dedicar ao código, talvez a única configuração que você deva fazer é para sua própria comodidade modificar o caminho onde serão salvos os arquivos.

A tela inicial possui a esquerda um espaço dedicado ao código, e a

direita um visualizador de variáveis assim como um console que mostra em tempo real certas execuções de blocos de código.

Apenas como exemplo, rodando este mesmo código criado

anteriormente, no Spyder podemos em tempo real fazer a análise das operações sobre as variáveis, assim como os resultados das mesmas via terminal.

Explorador de Variáveis:

 

Visualizando Variáveis:

Terminal: