ADG Soluções

Este artigo será dividido em várias partes, vou falar sobre as Redes Neurais propriamente ditas e como implementar alguns algorítmos usando Python, nesta primeira parte vamos ver o básico e a medida que os artigos forem sendo publicados ver coisas mais avançadas.

Perceba que o objetivo é demonstrar as implementações em Python e não ver teoria aprofundada de Redes Neurais, para isso recomendo o livro do Haykin.

Apresentando as Redes Neurais

O que são? – “São sistemas de processamento de sinais ou de informações, compostos por um grande número de processadores elementares chamados neurônios artificiais, operando de forma paralela e distribuída, de modo a resolver um determinado problema físico/computacional.”

Esquema! – (X1, X2, …, Xn) dot (W1, W2, …, Wn) — F(x) — Y

Isso significa que uma Rede Neural, de um neurônio apenas, é um combinador linear que passa por uma função de ativação e dá um resultado Y, o mais interessante é que podemos programá-la para que ela dê o resultado que você deseje! Com isso podemos fazer, dentre outras coisas, aproximadores de funções, associadores, classificação de padrões, predição futura, controle de sistemas, filtragem de sinais, compressão de dados, datamining, etc.

Redes Neurais podem ser de vários tipos, nesta parte básica vamos ver as mais simples, as Redes Neurais supervisionadas, que são treinadas (ou programadas) usando um conjunto de exemplos conhecidos, com atributos e respostas, e desta forma a Rede Neural “se acostuma” em dar os resultados desejados e passa a responder de acordo.

Programar uma Rede Neural é ajustar os valores do vetor W, de todos os neurônios, para que determinada entrada X, quando processada, resulte num valor Y desejado.

Um algoritmo simples

Este descreve apenas o funcionamento de um neurônio .

# -*- coding: utf8 -*-

from numpy import array, sign

class Neuron:

    def __init__(self, example, factor=0.1):
        self._bias = -1.0
        self._factor = factor
        x, self._d = example
        self._x = array([self._bias]+x)
        self._w = array([0.0]*(len(self._x)))
        self._y = None

        self.train(example)

    def train(self, example):
        x, self._d = example
        self._x = array([self._bias]+x)
        self._y = self._sign(self._sum())
        if self._y != self._d:
            self._adjust_w()

    def execute(self, x):
        self._x = array([self._bias]+x)
        self._y = self._sign(self._sum())
        return self._y

    def _error(self):
        return self._d - self._y

    def _sum(self):
        return (self._x*self._w).sum()

    def _sign(self, v):
        if sign(v) < 0:
            y = 0
        else:
            y = sign(v)
        return y

    def _adjust_w(self):
        self._w += self._factor * self._x * self._error()

E para executar o perceptron, que é o que irá apresentar os exemplos ao neurônio, temos:

# -*- coding: utf8 -*-

from Neuron import Neuron
from random import randint

class Perceptron:

    def __init__(self, examples, max_epochs=100):
        self._examples = examples
        self._this_epoch_examples = list(self._examples)
        self._max_epochs = max_epochs
        self._epoch = 0
        self._neuron = Neuron(self._rand_example())
        self.train()

    def train(self):
        while self._epoch <= self._max_epochs:
            self._this_epoch_examples = list(self._examples)
            for i in range(len(self._this_epoch_examples)):
                self._neuron.train(self._rand_example())
            print "Epoch: %d" % self._epoch
            self._epoch += 1

    def execute(self, x):
        return self._neuron.execute(x)

    def _rand_example(self):
        lenght = len(self._this_epoch_examples)
        i = randint(0,lenght-1)
        return self._this_epoch_examples.pop(i)

Execute as classes acima usando

# -*- coding: utf8 -*-

from Perceptron import Perceptron

# AND
examples_and = [
        [[1,1],1],
        [[1,0],0],
        [[0,1],0],
        [[0,0],0]
        ]

nn = Perceptron(examples_and)
nn.execute([1,0])

Analise o objeto criado, seus métodos e pesos, verifique que com o método “execute” você poderá testar se as respostas estão sendo dadas corretamente.

Aguarde a parte 2 deste artigo para mais detalhes…

Esse post foi publicado de quinta-feira, 11 de outubro de 2007 às 9:03, e arquivado em programação. Você pode acompanhar os comentários desse post através do feed RSS 2.0. Você pode comentar ou mandar um trackback do seu site pra cá. Tags: ia, programação, python, redesneurais