2018 Dr. Walter F. de Azevedo Jr. azevedolab.net

Transcrição

1 2018 Dr. Walter F. de Azevedo Jr. azevedolab.net 1

2 Introdução às Expressões Booleanas Circuitos digitais encontrados nos processadores são baseados num formalismo matemático chamado Álgebra de Boole. Não é objetivo da disciplina entrar em detalhes desse formalismo matemático, mas é necessário um conhecimento básico do seu funcionamento para que possamos entender os conjuntos treinos (training sets) que serão usados para treinar redes neurais. Uma expressão booleana envolve variáveis binárias que aqui serão representadas pelas letras maiúsculas. Abaixo temos um circuito elétrico simples, que representa a variável booleana A. Circuito aberto, sem corrente elétrica A A = 0 Circuito fechado, com corrente elétrica A A = 1 2

3 Introdução às Expressões Booleanas Uma variável binária, ou booleana, pode assumir valores 1 e 0. Na situação 1, temos o equivalente elétrico de um circuito fechado, onde a corrente elétrica circula. Na situação 0, não temos corrente elétrica circulando no circuito. Na linguagem Python, dispomos de operadores lógicos ou funções lógicas AND e OR. As expressões booleanas são equações que envolvem funções lógicas aplicadas às variáveis booleanas. Circuito aberto, sem corrente elétrica A A = 0 Circuito fechado, com corrente elétrica A A = 1 3

4 Introdução às Expressões Booleanas Abaixo temos a expressão booleana A AND B. Normalmente representamos em expressões booleanas a função lógica AND por ponto de multiplicação (.). Assim, a expressão booleana Q = A.B significa A AND B. A expressão booleana A.B é equivalente a um circuito elétrico em série mostrado abaixo. Equivalente Elétrico A B Q= A.B 4

5 Introdução às Expressões Booleanas Como temos duas variáveis booleanas e cada variável pode ter dois estados (0 ou 1), podemos mapear os quatro estados possíveis da expressão booleana Q = A.B, como indicado na tabela abaixo. Chamamos a essa tabela de tabela da verdade. À direita abaixo temos o símbolo do circuito digital de uma porta lógica AND de duas variáveis. A porta lógica AND é o circuito que implementa a expressão booleana Q = A.B. Equivalente Elétrico A B Q= A.B Tabela da Verdade A B Q=A.B A B Porta AND A.B 5

6 Introdução às Expressões Booleanas A função lógica OR é representada pelo sinal de soma (+). Abaixo temos o equivalente elétrico, a tabela da verdade e a porta lógica para a expressão booleana Q = A + B. A Q= A+B B Tabela da Verdade A B Q=A+B A B Porta OR A+B 6

7 Introdução às Expressões Booleanas Abaixo temos a definição da função lógica XOR, chamada OR exclusivo. A expressão booleana para a função lógica XOR tem a seguinte forma, Q = A + B. A diferença com relação à função lógica OR está no resultado obtido quando ambas entradas assumem o valor 1, no caso da XOR o resultado é 0. Tabela da Verdade A B Q=A + B A B Porta XOR A + B 7

8 Introdução às Expressões Booleanas Podemos ter a função lógica NOT, também chamado de circuito inversor. A tabela da verdade tem uma entrada e a saída é a negação da entrada. Temos dois símbolos para a função lógica NOT, indicados abaixo. A expressão booleana da função lógica NOT usa _ uma barra horizontal sobre a variável para indicar negação ( A ), lê-se A barra. A _ A Porta NOT Tabela da Verdade A Q= _ A A _ A Porta NOT 8

9 Introdução às Expressões Booleanas Podemos aplicar a negação à função lógica AND, o que gera a função lógica chamada NAND. A expressão booleana tem a seguinte forma: Q = A.B. A tabela da verdade e o símbolo da função lógica NAND estão mostrados abaixo. Tabela da Verdade A B Q= A.B A B Porta NAND A.B 9

10 Introdução às Expressões Booleanas De forma análoga, temos a negação da função lógica OR, chamada NOR. Segue a expressão booleana da função lógica NOR: Q = A B. Abaixo temos a tabela da verdade e o símbolo para a função lógica NOR. Tabela da Verdade A B Q= A B A B Porta NOR A B 10

11 Introdução às Expressões Booleanas Podemos ter funções lógicas com mais de duas variáveis. Para ilustrar, vamos considerar uma função lógica AND de três variáveis. Essa função lógica tem a seguinte expressão booleana: Q = A.B.C. A tabela da verdade e a porta lógica para função lógica AND de três variáveis são mostradas abaixo. Tabela da Verdade A B C Q=A.B.C A B C Porta AND A.B.C 11

12 Introdução às Expressões Booleanas Agora vejamos a função lógica OR de três variáveis. A tabela da verdade e o símbolo são mostrados abaixo. Podemos ter funções lógicas com N entradas. Essas funções lógicas podem ser mapeadas com tabelas da verdade de 2 N estados. Por exemplo, uma tabela da verdade para uma função lógica NAND de 4 variáveis tem 16 estados. Tabela da Verdade A B C Q=A+B+C A B C A+B+C Porta OR 12

13 Introdução às Expressões Booleanas Podemos ter expressões booleanas com a combinação de diferentes funções lógicas. Vamos considerar a expressão booleana Q = A.B + C. A tabela da verdade está mostrada abaixo. A coluna A.B foi incluída só para auxiliar na determinação da coluna final, com a expressão booleana. Tabela da Verdade A B C A.B Q=A.B+C

14 Introdução às Expressões Booleanas Quando avaliamos a expressão booleana Q = A.B + C, inicialmente identificamos as funções lógicas AND e determinamos seus valores na tabela da verdade (em vermelho). Em seguida operamos a função lógica OR com a coluna obtida (A.B), o resultado é mostrado na última coluna da tabela. No slide seguinte temos o circuito. Tabela da Verdade A B C A.B Q=A.B+C

15 Introdução às Expressões Booleanas Abaixo temos o circuito para expressão booleana Q = A.B + C. A A.B B A.B+C C 15

16 Introdução às Expressões Booleanas Abaixo temos a tabela da verdade para expressão booleana Q = A.B + A.C. A tabela da verdade está mostrada abaixo. No slide seguinte temos o circuito. Tabela da Verdade A B C A.B A.C Q=A.B+A.C

17 Introdução às Expressões Booleanas Abaixo temos o circuito para expressão booleana Q = A.B + A.C. A A.B B A.B+A.C A A.C C 17

18 Introdução às Expressões Booleanas Vamos determinar a tabela da verdade para expressão booleana Q = A+B + A.C. Os resultados estão mostrados abaixo. Tabela da Verdade A B C A+B A.C Q=A+B+A.C

19 Introdução às Expressões Booleanas Abaixo temos o circuito para expressão booleana Q = A + B + A.C. A A+B B A+B + A.C A A.C C 19

20 Programa boolean2csv3vars.py Abaixo temos o código de um programa simples (boolean2csv3vars.py) para gerar um arquivo CSV com a tabela da verdade de uma expressão booleana. No código temos a função lógica AND de três variáveis, Q = A.B.C. A linha em destaque em vermelho tem a expressão booleana de três variáveis, onde usamos o símbolo and para o operador lógico AND. A tabela da verdade é gerada e armazenada no arquivo truth_table_001.csv. Efetivamente em 10 linhas de código geramos um arquivo CSV para a tabela da verdade de uma expressão booleana. # Boolean expressions in Python csv = open("truth_table_001.csv","w") csv.write("a,b,c,q = A. B. C\n") print("a, B, C, Q = A. B. C") # Nested loop for a booleaan expression with 3 variables for A in range(2): for B in range(2): for C in range(2): Q = A and B and C # Boolean expression print(a,",",b,",",c,",",q) csv.write(str(a)+","+str(b)+","+str(c)+","+str(q)+"\n") csv.close() 20

21 Programa boolean2csv3vars.py Abaixo temos o resultado da execução do código boolean2csv3vars.py. A tabela gerada está armazenada no arquivo truth_table_001.csv. A, B, C, Q = A. B. C 0, 0, 0, 0 0, 0, 1, 0 0, 1, 0, 0 0, 1, 1, 0 1, 0, 0, 0 1, 0, 1, 0 1, 1, 0, 0 1, 1, 1, 1 truth_table_001.csv A,B,C,Q= A. B. C 0,0,0,0 0,0,1,0 0,1,0,0 0,1,1,0 1,0,0,0 1,0,1,0 1,1,0,0 1,1,1,1 21

22 Programa boolean2csv3vars.py Modificaremos o código(boolean2csv3vars.py) para gerar um arquivo CSV da tabela da verdade da expressão booleana Q = A+B+C. As linhas modificadas estão destacadas em vermelho. Usamos o símbolo para o operador lógico OR. # Boolean expressions in Python csv = open("truth_table_002.csv","w") csv.write("a,b,c,q = A + B + C\n") print("a, B, C, Q = A + B + C") # Nested loop for a booleaan expression with 3 variables for A in range(2): for B in range(2): for C in range(2): Q = A or B or C # Boolean expression print(a,",",b,",",c,",",q) csv.write(str(a)+","+str(b)+","+str(c)+","+str(q)+"\n") csv.close() 22

23 Programa boolean2csv3vars.py Abaixo temos o resultado da execução do código boolean2csv3vars.py com a nova expressão booleana. A tabela gerada está armazenada no arquivo truth_table_002.csv, mostrada à direita. truth_table_002.csv A, B, C, Q = A. B. C 0, 0, 0, 0 0, 0, 1, 1 0, 1, 0, 1 0, 1, 1, 1 1, 0, 0, 1 1, 0, 1, 1 1, 1, 0, 1 1, 1, 1, 1 A,B,C,Q = A. B. C 0,0,0,0 0,0,1,1 0,1,0,1 0,1,1,1 1,0,0,1 1,0,1,1 1,1,0,1 1,1,1,1 23

24 Programa boolean2csv3vars.py Usaremos o código boolean2csv3vars.py para implementarmos a expressão booleana Q = A.B+C. As linhas modificadas estão destacadas em vermelho. # Boolean expressions in Python csv = open("truth_table_003.csv","w") csv.write("a,b,c,q = A. B + C\n") print("a, B, C, Q = A. B + C") # Nested loop for a booleaan expression with 3 variables for A in range(2): for B in range(2): for C in range(2): Q = A and B or C # Boolean expression print(a,",",b,",",c,",",q) csv.write(str(a)+","+str(b)+","+str(c)+","+str(q)+"\n") csv.close() 24

25 Programa boolean2csv3vars.py O código com a nova expressão booleana gerou os resultados mostrados abaixo. A tabela gerada está armazenada no arquivo truth_table_003.csv, mostrada à direita. A, B, C, Q = A. B + C 0, 0, 0, 0 0, 0, 1, 1 0, 1, 0, 0 0, 1, 1, 1 1, 0, 0, 0 1, 0, 1, 1 1, 1, 0, 1 1, 1, 1, 1 truth_table_003.csv A,B,C,Q = A. B + C 0,0,0,0 0,0,1,1 0,1,0,0 0,1,1,1 1,0,0,0 1,0,1,1 1,1,0,1 1,1,1,1 25

26 Programa boolean2csv3vars.py Implementaremos a expressão booleana Q = A.B + A.C, o código está mostrado abaixo. # Boolean expressions in Python csv = open("truth_table_004.csv","w") csv.write("a,b,c,q = A. B + A. C\n") print("a, B, C, Q = A. B + A. C") # Nested loop for a booleaan expression with 3 variables for A in range(2): for B in range(2): for C in range(2): Q = A and B or A and C # Boolean expression print(a,",",b,",",c,",",q) csv.write(str(a)+","+str(b)+","+str(c)+","+str(q)+"\n") csv.close() 26

27 Programa boolean2csv3vars.py A nova expressão booleana gerou uma tabela da verdade que está armazenada no arquivo truth_table_004.csv. Os resultados estão indicado a seguir. A, B, C, Q = A. B + A. C 0, 0, 0, 0 0, 0, 1, 0 0, 1, 0, 0 0, 1, 1, 0 1, 0, 0, 0 1, 0, 1, 1 1, 1, 0, 1 1, 1, 1, 1 truth_table_004.csv A,B,C,Q = A. B + A. C 0,0,0,0 0,0,1,0 0,1,0,0 0,1,1,0 1,0,0,0 1,0,1,1 1,1,0,1 1,1,1,1 27

28 Programa boolean2csv3vars.py Vamos encerrar a implementação de expressões booleana de 3 variáveis com a expressão Q = A+B + A.C. O código está mostrado abaixo. # Boolean expressions in Python csv = open("truth_table_005.csv","w") csv.write("a,b,c,q = A + B + A. C\n") print("a, B, C, Q = A + B + A. C") # Nested loop for a booleaan expression with 3 variables for A in range(2): for B in range(2): for C in range(2): Q = A or B or A and C # Boolean expression print(a,",",b,",",c,",",q) csv.write(str(a)+","+str(b)+","+str(c)+","+str(q)+"\n") csv.close() 28

29 Programa boolean2csv3vars.py Os resultados para a expressão booleana Q = A+B + A.B estão mostrados abaixo. A, B, C, Q = A + B + A. C 0, 0, 0, 0 0, 0, 1, 0 0, 1, 0, 1 0, 1, 1, 1 1, 0, 0, 1 1, 0, 1, 1 1, 1, 0, 1 1, 1, 1, 1 truth_table_005.csv A,B,C,Q = A + B + A. C 0,0,0,0 0,0,1,0 0,1,0,1 0,1,1,1 1,0,0,1 1,0,1,1 1,1,0,1 1,1,1,1 29

30 Potencial de Membrana (mv) Potencial de Ação Quando um neurônio sofre um estímulo elétrico, acima do potencial limiar, este entra num processo chamado de potencial de ação. O aumento do potencial leva o neurônio a uma situação onde há influxo de Sódio. Entram em ação dois canais transmembranares, os canais de Sódio e Potássio, ambos dependentes do potencial elétrico da membrana. Aqui cabe uma pequena observação. Na linguagem física não usamos o termo voltagem para indicar potencial elétrico, contudo, a grande maioria dos textos de fisiologia em português, quando referem-se aos canais citados, usam a denominação dependentes de voltagem. No presente texto usaremos os termos canais dependentes de voltagem, para mantermos os termos usados na área de fisiologia Fases indicadas no gráfico acima 1 Potencial de repouso 2 Despolarização 3 Repolarização 4 Hiperpolarização Corrente elétrica de estímulo 4 Tempo (ms) Potencial de ação 30

31 Potencial de Membrana (mv) Potencial de Ação As etapas canônicas do potencial de ação ocorrem devido à ação coordenada dos canais de Sódio e Potássio dependentes de voltagem. A abertura do canal de Sódio dependente de voltagem (despolarização), o fechamento do canal de Sódio e abertura do canal de Potássio (repolarização e hiperpolarização), conforme vemos no gráfico ao lado. A linha roxa indica o estímulo que é dado para o início do potencial de ação, veja que o estímulo não está em escala com o potencial indicado pela linha vermelha. O eixo horizontal é o eixo do tempo (em ms), e o eixo vertical o eixo do potencial de membrana (em mv). A linha vermelha indica a variação do potencial de membrana durante as diferentes etapas do potencial de ação Fases indicadas no gráfico acima 1 Potencial de repouso 2 Despolarização 3 Repolarização 4 Hiperpolarização Corrente elétrica de estímulo 4 Tempo (ms) Potencial de ação 31

32 Modelo de Hodgkin-Huxley O modelo computacional para a descrição da variação do potencial de membrana em função do tempo é descrito pelo modelo de Hodgkin-Huxley (Hodgkin & Huxley, 1952). Esse modelo faz uso de equações diferenciais para dedução do modelo computacional e é considerado o primeiro modelo consistente da área de de Biologia de Sistemas Computacional. Gráfico do potencial contra o tempo (linha vermelha), gerado pelo HHSim ( Acesso em: 25 de março de

33 Modelo de Hodgkin-Huxley No modelo de Hodgkin-Huxley (Hodgkin & Huxley, 1952) são consideradas as condutâncias dos íons Sódio e Potássio, sendo o restante dos íons considerados de forma integrada e com uma participação minoritária no fenômeno do potencial de ação. A condutância indica a facilidade com que o íon atravessa a membrana. Gráfico do potencial contra o tempo (linha vermelha), gerado pelo HHSim ( Acesso em: 25 de março de

34 Modelo de Hodgkin-Huxley Vamos usar o programa Graphical Hodgkin-Huxley Simulator (HHSim) para a simulação do potencial de ação. Na figura abaixo temos a situação de potencial de repouso. A linha vermelha indica o potencial da membrana (em repouso), a linha roxa indica o estímulo aplicado, a linha amarela a condutância do Sódio e a verde a condutância do Potássio. Ao clicarmos no botão Stim1, iniciamos o potencial de ação. Gráfico do potencial contra o tempo (linha vermelha), gerado pelo HHSim ( Acesso em: 25 de março de

35 Modelo de Hodgkin-Huxley Aplicamos um estímulo, linha roxa, temos que o potencial de membrana atinge um valor acima do potencial limiar (vermelho). Nessa situação, abrem-se os canais de Sódio dependentes de voltagem. Cofirmarmos a situação, verificando a condutância do Sódio (linha amarela), que começa a subir, indicando o influxo de Sódio. O eixo horizontal é o do tempo. Todo evento está registrado em pouco mais de 20 ms. Gráfico do potencial contra o tempo (linha vermelha), gerado pelo HHSim ( Acesso em: 25 de março de

36 Modelo de Hodgkin-Huxley Comparando-se as condutâncias, vemos que a condutância do Sódio (linha amarela) atinge o valor máximo, antes da a condutância do Potássio (linha amarela). Isto devese ao fato do canal de Sódio dependente de voltagem abrir-se antes do canal de Potássio dependente de voltagem. Além disso, o canal de Sódio tem dois portões, o de ativação e o de inativação. Gráfico do potencial contra o tempo (linha vermelha), gerado pelo HHSim ( Acesso em: 25 de março de

37 Modelo de Hodgkin-Huxley Para que inicie o potencial de ação, o portão de inativação do canal de Sódio deve estar aberto e o portão de ativação fechado. Essa situação corresponde ao repouso no gráfico baixo e a célula está pronta para disparar um potencial de ação. Gráfico do potencial contra o tempo (linha vermelha), gerado pelo HHSim ( Acesso em: 25 de março de

38 Modelo de Hodgkin-Huxley Com um estímulo acima do potencial limiar, abre-se o portão de ativação do canal de Sódio e ocorre influxo de Sódio e o aumento do potencial de membrana, é a fase de despolarização do potencial de ação. Podemos confirmar pela análise da condutância do Sódio, indicada pela linha amarela. Veja que ela atinge o pico antes da linha verde, que indica a condutância do Potássio. Gráfico do potencial contra o tempo (linha vermelha), gerado pelo HHSim ( Acesso em: 25 de março de

39 Modelo de Hodgkin-Huxley Após aproximadamente 1 ms, o portão de inativação do canal de Sódio fecha-se. Veja que neste momento (pico do potencial de membrana, aproximadamente + 40 mv) o portão de ativação do canal de Sódio continua aberto. Quem fecha-se é o portão de inativação. O portão de ativação continua aberto por alguns milisegundos. O fechamento do portão de inativação cessa a entrada de Sódio. Gráfico do potencial contra o tempo (linha vermelha), gerado pelo HHSim ( Acesso em: 25 de março de

40 Modelo de Hodgkin-Huxley Outro aspecto importante do portão de inativação, é que ele garante um período refratário da célula, onde novos estímulos não geram novos potenciais de ação. Durante a repolarização (fase descendente), o Potássio sai da célula e o potencial volta a ter valores negativos. Podemos ver que a condutância do Potássio retorna a zero de forma mais lenta que a condutância do Sódio. Gráfico do potencial contra o tempo (linha vermelha), gerado pelo HHSim ( Acesso em: 25 de março de

41 Modelo de Hodgkin-Huxley Depois de poucos milisegundos, ambos canais estão fechados, como vemos com as condutâncias retornando para o valor zero. Depois de mais alguns milisegundos, o potencial de membrana (linha vermelha) retorna ao valor de repouso. Gráfico do potencial contra o tempo (linha vermelha), gerado pelo HHSim ( Acesso em: 25 de março de

42 Exercícios de Programação 1. Modifique o código boolean2csv3vars.py, para que sejam geradas as tabelas da verdade para expressões booleanas de duas variáveis. O novo código irá chamar-se boolean2csv2vars.py. Use o novo código para gerar as tabelas da verdade para as expressões booleanas: Q = A + B e Q = A.B. 2. Modifique o código boolean2csv3vars.py, para que sejam geradas as tabelas da verdade para expressões booleanas de quatro variáveis. O novo código irá chamar-se boolean2csv4vars.py. Use o novo código para gerar as tabelas da verdade para as expressões booleanas: Q = A + B + C + D e Q = A.B.C.D. 3. Considere as fases canônicas do potencial de ação e determine uma expressão booleana para simular seu comportamento. Considere que quando temos potencial de ação a saída é 1, para as outras situações a saída é 0. Considere que temos 3 variáveis booleanas, uma para o portão de ativação do canal de Sódio, a segunda para o portão de inativação do canal de Sódio e a terceira para o canal de Potássio. Implemente a expressão booleana em Python. O programa irá chamar-se pa.py. 42

43 Python para Redes Neurais Necessitamos de alguns recursos do Python para a implementação de redes neurais. Um deles é o choice da biblioteca random. Basicamente, o choice(a) escolhe de forma aleatória um elemento de uma lista ou array. No código abaixo, dentro do loop for, toda vez que choice(a) é chamado, ele retorna um elemento de posição aleatória da lista a. from random import choice a = [1,1,2,3,5,8,13,21,55] for i in range(len(a)): b = choice(a) print(b) Ao executarmos o código acima, temos o seguinte resultado

44 Python para Redes Neurais Usaremos na implementação de redes neurais o produto escalar da biblioteca NumPy (np.dot(a,b)). No código abaixo, temos dois arrays, a e b. O dot(a,b) faz o produto escalar: a 1 b 1 + a 2 b a n b n, ou seja, retorna um escalar (número puro). import numpy as np a = np.array([1,2,3,4,5]) b = np.array([0.1,0.2,0.3,0.4,0.5]) c = np.dot(a,b) print(c) Ao executarmos o código acima, temos o produto escalar como resultado

45 Introdução às Redes Neurais A abordagem computacional chamada rede neural usa uma visão simplificada do neurônio, onde a inspiração biológica restringe-se a acharmos uma função matemática que dispara, ou seja, assume valor 1 para um dado conjunto de entradas. Usando uma definição mais formal, temos que uma rede neural é um sistema computacional composto por um certo número de elementos altamente conectados que processam informação por meio de sua resposta dinâmica a um conjunto externo de entradas. "...a computing system made up of a number of simple, highly interconnected processing elements, which process information by their dynamic state response to external inputs. In "Neural Network Primer: Part I" by Maureen Caudill, AI Expert, Feb

46 Introdução às Redes Neurais A figura à direita traz uma representação simplificada do neurônio. Onde destacamos os dendritos, corpo celular, cone de implantação e axônio. O cone de implantação funciona como um processador da informação que chega ao neurônio. Ele realiza a soma dos sinais, e quando a soma é maior que potencial limiar, o cone de implantação dispara um potencial de ação que propaga-se ao longo do axônio. Uma rede neural é uma abstração do funcionamento do neurônio, onde os dendritos são representados por entradas, o cone de implantação uma função matemática e o axônio a saída. Corpo celular Núcleo Axônio Dendritos Cone de implantação Terminais axonais 46 Diagrama esquemático de um neurônio.

47 Introdução às Redes Neurais O Perceptron é uma forma simples de rede neural usada para classificação binária. No Perceptron temos uma camada de entrada composta por um vetor com dimensão n, representado por (x 1,x 2,...,x n ). À cada entrada x i multiplicamos um peso w i, e determinamos uma função soma ponderada, s, indicada a seguir. n s w x i i i 1 Essa função s é usada como argumento de uma função degrau. Normalmente são usadas as funções sigmoide, Heaviside e tangente hiperbólica como funções degrau. O diagrama esquemático ao lado ilustra o funcionamento do Perceptron. x 1 x 2 x n... w 1 w 2 w n Entradas Pesos w 1.x 1 w 2.x 2 w n.x n Pesos.Entrada Saída Função s n s w x i i i 1 Função Degrau 47

48 Introdução às Redes Neurais Abaixo temos os gráficos das funções sigmóide e tangente hiperbólica. 48

49 Programa perceptron001.py Aqui temos o código da implementação de um Perceptron de uma camada com a função sigmóide como função degrau. O código está sem comentários e explicaremos seu funcionamento. O código abaixo está no arquivo perceptron001.py e foi levemente baseado no código descrito por Danilo Bargen em 2013 (disponível aqui, acessado em 25 de março de 2018). Foi usada a tabela da verdade da função lógica NOR de duas variáveis. O código pode ser facilmente modificado para outras portas lógicas. from random import choice import numpy as np def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) 49

50 Programa perceptron001.py Inicialmente importamos as bibliotecas random e NumPy. Usaremos o choice da biblioteca random, que tendo um array como argumento retorna elementos do array de forma aleatória. Assim podemos atribuir cada elemento do array usado como conjunto treino. from random import choice import numpy as np def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) 50

51 Programa perceptron001.py Na sequência definimos a função f, que retorna a função sigmóide, tendo x como parâmetro. Abaixo temos a equação da função sigmóide (f). Usamos a função np.exp() da biblioteca NumPy. f 1 1 e x from random import choice import numpy as np def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) 51

52 Programa perceptron001.py Em seguida definimos um array com o conjunto treino. Esse array traz a porta lógica NOR. Além da tabela da verdade da porta lógica OR, o array tem o bias (x 0 ) que será multiplicado por w 0. Abaixo temos a definição das posições dos elementos do array. A B x 0 Q np.array([0,0,1]), 1), from random import choice import numpy as np def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) 52

53 Programa perceptron001.py As duas primeiras entradas do array em cada tuple são as entradas da função binária do conjunto treino. A terceira entrada do array é o bias. Esse número será multiplicado por w 0 e serve para deslocarmos o valor limite (threshold). A B x 0 Q np.array([0,0,1]), 1), from random import choice import numpy as np def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) 53

54 Programa perceptron001.py O valor limite (threshold) também é conhecido como fronteira de decisão (boundary decision). O valor é sempre 1, de forma que sua influência é controlada pelo peso w 0. O segundo valor do tuple é o valor esperado da função lógica. A B x 0 Q np.array([0,0,1]), 1), from random import choice import numpy as np def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) 54

55 Programa perceptron001.py Na sequência temos valores iniciais atribuídos às variáveis n_vars (número de variáveis explanatórias do tipo inteiro), errors (lista para os erros de cada iteração do tipo float), lr (taxa de aprendizado do tipo float) e w (um array com os pesos iniciais do tipo float). Os pesos são elementos de um array que inicialmente recebem valores aleatórios entre 0 e 1. A lista errors será usada em outra versão do código para gerarmos um gráfico da evolução dos erros em cada iteração. from random import choice import numpy as np def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) 55

56 Programa perceptron001.py No loop principal, inicialmente é selecionado de forma aleatória uma entrada do conjunto treino com o choice da biblioteca random. As entradas da função lógica são atribuídas à variável x. O resultado esperado para a entrada é atribuído à variável y. Vejam que nesta implementação do Perceptron, em cada iteração do loop é usado um elemento aleatório do array training_set. from random import choice import numpy as np def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) 56

57 Programa perceptron001.py Na sequência é calculado o produto escalar das entradas (x i ) com os pesos (w i ), com o dot(w,x) da biblioteca NumPy. O resultado é um escalar atribuído à variável s. Na linha seguinte é usada a função degrau, tendo como argumento o valor atribuído à variável s. A diferença entre o valor esperado (y) e o valor calculado (f) é determinada e atribuída à variável error. from random import choice import numpy as np def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) 57

58 Programa perceptron001.py A diferença entre o valor esperado (y) e o valor calculado (f) é determinada e adicionada à lista errors. Essa lista armazena o erro para cada iteração do Perceptron. Podemos usar essa lista para avaliar a convergência ou não do Perceptron. from random import choice import numpy as np def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) 58

59 Programa perceptron001.py Na última linha do loop, os pesos (w) são atualizados. Caso o valor esperado (y) seja maior que o valor calculado (f), os pesos são aumentados, caso contrário são diminuídos. Os novos pesos são o resultado da multiplicação da taxa de aprendizagem (lr), error e as entradas x. Uma vez finalizado esse loop, temos os pesos otimizados para a função lógica NOR. from random import choice import numpy as np def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) 59

60 Programa perceptron001.py O loop final mostra os valores calculados para função lógica NOR. from random import choice import numpy as np def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) 60

61 Programa perceptron001.py Abaixo temos a saída gerada ao executarmos o código perceptron001.py. Vejam que nossa rede neural gerou resultados próximos aos esperados para uma função lógica NOR. Notem que os valores obtidos podem variar, pois temos pesos aleatórios como valores iniciais, mas espera-se que para a entrada [0,0] a saída mais próxima de 1. O funcionamento melhora com o aumento do número de iterações. [0 0] [0 1] [1 0] [1 1] Tabela da Verdade A B Q= A B

62 Programa perceptron002.py Modificaremos o código perceptron001.py, de forma a gerarmos o gráfico dos erros para cada iteração do Perceptron. O novo código chama-se perceptron002.py e está listado abaixo. As novidades estão em vermelho. from random import choice import numpy as np import matplotlib.pyplot as plt def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) plt.plot(errors) plt.ylim([-1,1]) plt.show() plt.savefig("errors.png") 62

63 Programa perceptron002.py Inicialmente importamos a biblioteca Matplotlib. Depois da rede neural ter gerado os pesos otimizados, geramos o gráfico dos erros nas 4 últimas linhas. from random import choice import numpy as np import matplotlib.pyplot as plt def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.2, 100, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) plt.plot(errors) plt.ylim([-1,1]) plt.show() plt.savefig("errors.png") 63

64 Programa perceptron002.py Abaixo temos os novos resultados, onde geramos o gráfico da evolução erros para cada iteração. Vemos uma diminuição do erro conforme avançamos nas iterações. Para um total de 100 iterações, ainda temos uma grande flutuação do erro. Podemos melhorar o resultado, se aumentarmos o número de iterações e a taxa de aprendizado. [0 0] [0 1] [1 0] [1 1]

65 Programa perceptron002.py A linha modificada está indicada em vermelho no código abaixo. A nova taxa de aprendizado é 0,8 e o número de iterações é ifrom random import choice import numpy as np import matplotlib.pyplot as plt def f(x): f = 1 / (1 + np.exp(-x)) return f training_set = [(np.array([0,0,1]), 1), (np.array([0,1,1]), 0), (np.array([1,0,1]), 0),(np.array([1,1,1]), 0)] n_vars = len(training_set[0][0]) errors = [] lr, n_iter, w = 0.8, 1000, np.random.rand(n_vars) for i in range(n_iter): x,y = choice(training_set) s = np.dot(w, x) error = y - f(s) errors.append(error) w += lr * error * x for x, _ in training_set: s = np.dot(w, x) print(x[:n_vars-1],(n_vars-1)*"\t","%.3f"%f(s)) plt.plot(errors) plt.ylim([-1,1]) plt.show() plt.savefig("errors.png") 65

66 Programa perceptron002.py Com os novos valores para a taxa de aprendizado e número de iterações, vemos a convergência do erro para valores próximo de zero. Na tabela dos resultados mostrados na tela, também vemos claramente a melhora do desempenho do Perceptron. [0 0] [0 1] [1 0] [1 1]

67 Exercícios de Programação 4. No código perceptron002.py, implemente as seguintes funções lógicas como conjunto treino. De duas variáveis: AND, OR e NAND. De três variáveis: AND, OR, NAND e NOR. De quatro variáveis: AND, OR, NAND e NOR. 5. Modifique o código perceptron002.py, de forma que a função tangente hiperbólica seja a função degrau. O novo código deve chamar-se perceptron003.py. 6. No código perceptron003.py, implemente as seguintes funções lógicas como conjunto treino. De duas variáveis: AND, OR, NAND e NOR. De três variáveis: AND, OR, NAND e NOR. De quatro variáveis: AND, OR, NAND e NOR. 7. Compare o desempenho dos Perceptrons com as funções sigmóide e tangente hiperbólicas. 8. Modifique o código perceptron003.py, de forma que tenhamos uma classe 67 Perceptron() com os seguintes atributos: taxa de aprendizado (lr), pesos iniciais (w), número de iterações (n_iter). O novo código chama-se perceptron004.py.

68 Colophon This text was produced in a HP Pavillon dm4 notebook with 6GB of memory, a 500 GB hard disk, and an Intel Core i7 M GHz running Windows 7 Professional. Text and layout were generated using PowerPoint The image on the first slide was taken from on March 25 th Figures on slides were generated with Graphical Hodgkin-Huxley Simulator (HHSim). Figures on slides 48, 64, and 66 were generated with Matplotlib. This text uses Arial font. 68

69 Author I graduated in Physics (BSc in Physics) at University of Sao Paulo (USP) in I completed a Master Degree inapplied Physics also at USP (1992), working under supervision of Prof. Yvonne P. Mascarenhas, the founder of crystallography in Brazil. My dissertation was about X-ray crystallography applied to organometallics compounds (De Azevedo Jr. et al.,1995). During my PhD I worked under supervision of Prof. Sung-Hou Kim (University of California, Berkeley. Department of Chemistry), on a split PhD program with a fellowship from Brazilian Research Council (CNPq)( ). My PhD was about the crystallographic structure of CDK2 (De Azevedo Jr. et al., 1996). In 1996, I returned to Brazil. In April 1997, I finished my PhD and moved to Sao Jose do Rio Preto (SP, Brazil) (UNESP) and worked there from 1997 to In 1997, I started the Laboratory of Biomolecular Systems- Department of Physics-UNESP - São Paulo State University. In 2005, I moved to Porto Alegre/RS (Brazil), where I am now. My current position is coordinator of the Laboratory of Computational Systems Biology at Pontifical Catholic University of Rio Grande do Sul (PUCRS). My research interests are focused on application of computer simulations to analyze protein-ligand interactions. I'm also interested in the development of biological inspired computing and machine learning algorithms. We apply these algorithms to molecular docking simulations, protein-ligand interactions and other scientific and technological problems. I published over 160 scientific papers about protein structures and computer simulation methods applied to the study of biological systems (H-index: 36). These publications have over 4000 citations. I am editor for the following journals: 69

70 Referências -BRESSERT, Eli. SciPy and NumPy. Sebastopol: O Reilly Media, Inc., p. Link -DAWSON, Michael. Python Programming, for the Absolute Beginner. 3ed. Boston: Course Technology, p. -HACKELING G. Mastering Machine Learning with scikit-learn. Birmingham: Packt Publishing Ltd., p. Link -HETLAND, Magnus Lie. Python Algorithms. Mastering Basic Algorithms in the Python Language. 2ed. Nova York: Springer Science+Business Media LLC, p. Link -HODGKIN, ALAN L; HUXLEY, ANDREW F. "A quantitative description of membrane current and its application to conduction and excitation in nerve". Journal of Physiology, 1952; 117 (4): IDRIS, Ivan. NumPy 1.5. An action-packed guide dor the easy-to-use, high performance, Python based free open source NumPy mathematical library using real-world examples. Beginner s Guide. Birmingham: Packt Publishing Ltd., p. Link -KETKAR, NIKHIL. Deep Learning with Python. A Hands-on Introduction. Bangalore: Springer Science+Business Media, p. Link -LUTZ, Mark. Programming Python. 4ed. Sebastopol: O Reilly Media, Inc., p. Link -TOSI, Sandro. Matplotlib for Python Developers. Birmingham: Packt Publishing Ltd., p. Link Última atualização: 25 de março de