kardoso/RedesNeurais.md

## neural_padrao.py
#!/usr/bin/python3
# -*- coding: utf-8 -*-

# Redes neurais com as bibliotecas padrão do python
# implementando o algoritmo de treinamento e predição
# para um perceptron simples

import csv
import random

dataset = []
file_path = "CVS/File/Path"

with open(file_path) as file:
    # Ler arquivo
    data = csv.reader(file, delimiter=',')
    for line in data:
        # Converter linhas em float
        # Pois os elementos virão em string
        line = [float(elemento) for elemento in line]
        #Adicionar linha no dataset
        dataset.append(line)

# 80% para treinar e os outros 20% para fazer teste

# Separar elementos em elementos de teste e elementos de treino
# Porcentagem de treino
def treino_test_split(dataset, porcentagem):
    # "/" retorna um valor float de uma divisão
    # "//" retorna um valor inteiro(arredondado para baixo) de uma divisão
    percent = porcentagem * len(dataset) // 100
    # Gera o dataset de treino
    data_treino = random.sample(dataset, percent)
    # Gera o dataset de teste com o que sobra
    data_test = [data for data in dataset if data not in data_treino]

    # Montar um dataset, tanto treino quanto teste
    def montar(dataset):
        # x = dataset das variaveis
        # y = dataset de resultado
        x, y= [], []
        for data in dataset:
            # Pegar as variaveis atributo do dataset
            # das colunas 1 e 2
            x.append(data[1:3])
            # Pegar o atributo alvo
            # da columa 0
            y.append(data[0])
        return x, y

    x_train, y_train = montar(data_treino)
    x_test, y_test = montar(data_test)

    return x_train, y_train, x_test, y_test

x_treino, y_treino, x_teste, y_teste = treino_test_split(dataset, 80)

# Funcao sinal
def sinal(u):
    return 1 if u >= 0 else -1

# w = Peso (bias)
# x = Linha
# d = Saida original
# y = Saida treinada
def ajuste(w, x, d, y):
    # A taxa precisa ser um valor entre 0 e 1
    taxa_aprendizagem = 0.01
    return w + taxa_aprendizagem * (d-y) * x

# Treino
# x = Conjunto de amostras de treinamento
# d = Valor desejado para cada amostra
def perceptron_fit(x, d):
    # Limite de "convergencia"
    # Se a rede demorar muito para convergir
    # usa para limitar a rede
    # EX: Se demorar 1000 ou mais, é limitada
    epoca = 0
    # Pesos
    # Três numeros aleatorios entre 0 e 1
    w = [random.random() for i in range(3)]
    print(w)

    while True:
        erro = False
        # Criar a iteração sobre o x
        for i in range(len(x)):
            # "w[0]" é o bias
            u = sum([w[0]*-1, w[1]*x[i][0], w[2]*x[i][1]])
            # Receber o valor do sinal de u
            y = sinal(u)
            # Se a saida treinada for diferente da esperada
            if y != d[i]:
                w[0] = ajuste(w[0], -1, d[i], y)
                w[1] = ajuste(w[1], x[i][0], d[i], y)
                w[2] = ajuste(w[2], x[i][1], d[i], y)
                # O erro aconteceu
                # A rede esta falha
                erro = True
        epoca += 1
        if erro is False or epoca == 1000:
            break
    print("Épocas: " + str(epoca))
    return w

w_fit = perceptron_fit(x_treino, y_treino)
print(w_fit)

# Validacao dos dados
def perceptron_predict(x_teste, w_ajustado):
    y_predict = []
    # Iterar sobre o dataset
    for i in range(len(x_teste)):
        predict = sum([w_ajustado[0]*-1, w_ajustado[1]*x_teste[i][0], w_ajustado[2]*x_teste[i][1]])
        y_predict.append(sinal(predict))
    return y_predict

y_validado = perceptron_predict(x_teste, w_fit)
print(y_validado)

# Quanto a rede foi boa em predizer
def acuracia(y_teste, y_validado):
    total_acertos = 0
    for i in range(len(y_teste)):
        if y_teste[i] == y_validado[i]:
            total_acertos += 1
        else:
            pass
    # Total de acertos pelo total de amostras
    return total_acertos/len(y_validado)

accuracy = acuracia(y_teste, y_validado)
print(accuracy)

## neural_science.py
#!/usr/bin/python3
# -*- coding: utf-8 -*-

# Redes neurais com as bibliotecas pandas e scikit-learn
# treinamento e predição de um perceptron simples

# trabalhar com elementos lineares
from sklearn import linear_model
# selection para fazer o train_test_split
from sklearn import model_selection
# metrics para pegar acuracia
from sklearn import metrics
# pandas para encurtar os dados
import pandas as pd

file_path = "CVS/File/Path"

dataset = pd.read_csv(file_path)
# pegar todos os valores de todas as linhas
# pegar todos os valores da coluna 1 e adiante
x = dataset.iloc[:, 1:].values
# pegar valores alvo da primeira coluna
y = dataset.iloc[:, 0].values

# Criar o perceptron
perceptron = linear_model.Perceptron()

# Dividir os dados es teste e treino
x_train, x_test, y_train, y_test = model_selection.train_test_split(x, y, test_size=0.2, random_state=0)

# Treinar dados
classificador = perceptron.fit(x_train, y_train)
# Predizer dados
y_predict = classificador.predict(x_test)

# Exibit acurácia da predição
print(metrics.accuracy_score(y_test, y_predict))

## RedesNeurais.md

      
    Raw
  

              RedesNeurais.md
            
          
    Redes Neurais


Lippman(1997): São sistemas que podem adquirir, armazenar e utilizar conhecimentos experimentais que podem alcançar boa performance, devido à sua densa interconexão entre os nós da rede;
Trabalho proposto por McCulloch e Pitts em 1943;
Baseada em um neurônio biológico.

Redes neurais consistem em:


Entradas;
Pesos;
Neurônios intermediários;
Neurônios de saída;
Saídas.

O que pode ser feito com redes neurais:


Reconhecimento de padrão
Classificação de reconhecimento de imagens
Reconhecimento de luz

Perceptron simples


Forma mais simples de uma rede neural;


Possui uma única camada;


Resolvem apenas problemas lienarmente separáveis;


Utiliza, em geral, para classificação de padrões.


Cada entrada é multiplicada pelo seu peso, então são somadas, há uma função de ativação que divide cada entrada em classes, e fornece a saída.


Modelo matemático:


xi = entradas da rede;
wi = peso sináptico associado à entrada;

$\theta$ = limiar de atiavação (bias);

Serve para o valor não começar em 0, começa em um número e vai até onde precisa ir.
Mantém o algoritmo no hiperplano


u = potencial de ativação;
g(u) = função de ativação;
y = saída da rede;

$$
u = \sum_{i=1}^N x_{i}w_{i} - \theta
\[12pt]
y = g(u)
\[12pt]
u(t) =\left{
\begin{aligned}
1 \hspace{5mm} t\geq0
\\
0 \hspace{5mm} t<0
\end{aligned}
\right.
\[12pt]
$$

Se o valor de u, (t), for maior ou igual a zero pertence à classe 1, se não pertence à classe 0

Definições:


O perceptorn simples atua, traçando retas entre as classes, até conseguir valores de peso que "separem" todos os pontos;
O bias($\theta$) serve para aumentar os graus de liberdade, permitindo uma melhor adaptação por parte da rede neural ao conhecimento à ela fornecido.
Taxa de aprendizagem, um valor entre 0 e 1, diz o quão rápido a rede converge (Se for pequeno demora muito para convergir).

Algoritmo


####Treinamento [Fit]
Obter o conjunto de amostras de treinamento {$x^{(k)}$};
Associar o valor desejado {$d^{(k)}$} para cada amostra;
Iniciar o vetor de pesos {$w$} com valores aleatórios pequenos;
Especificar a taxa de aprendizagem {$\eta$};
Iniciar o contador de épocas (época = 0);
Repetir instruções até que o erro inexista:
Inicializa erro $\boldsymbol\leftarrow$ False;
Para todas as amostras de treinamento faça:
$\hspace{4mm}$u = $w^T$ . $x^{(k)}$
$\hspace{4mm}$y = g(u)
$\hspace{4mm}$Se y $\ne$ d faça:
$\hspace{8mm}$w $\boldsymbol\leftarrow$ w + $\eta$ * ($d^{(k)}$ - y) * $x^{(k)}$
$\hspace{8mm}$erro $\boldsymbol\leftarrow$ True
$\hspace{4mm}$época época + 1
Até que erro = False

####Operação (Validação) [Predict]
Obter conjunto de amostras para classificação;
Carregar o vetor de pesos {w}, ajustado no treinamento;
Para cada amostra {x} faça:
$\hspace{4mm}$u = $w^T$ * x
$\hspace{4mm}$y = g(u)
$\hspace{4mm}$Verificar saída:
$\hspace{8mm}$Se y = 0, x $\in$ à classe A
$\hspace{8mm}$Se y = 1, x $\in$ à classe B

Processo de aprendizado


Supervisionado: quando é utilizado um agente externo que indica à rede a resposta desejada para o padrão de entrada; Quando as variáveis são seguidas de valores alvo(já se sabe o valor que o resultado precisa ser);
Não supervisionado: quando não existe um agente externo indicando a resposta desejada para os padrões de entrada.
	#!/usr/bin/python3
	# -- coding: utf-8 --

	# Redes neurais com as bibliotecas padrão do python
	# implementando o algoritmo de treinamento e predição
	# para um perceptron simples

	import csv
	import random

	dataset = []
	file_path = "CVS/File/Path"

	with open(file_path) as file:
	# Ler arquivo
	data = csv.reader(file, delimiter=',')
	for line in data:
	# Converter linhas em float
	# Pois os elementos virão em string
	line = [float(elemento) for elemento in line]
	#Adicionar linha no dataset
	dataset.append(line)

	# 80% para treinar e os outros 20% para fazer teste

	# Separar elementos em elementos de teste e elementos de treino
	# Porcentagem de treino
	def treino_test_split(dataset, porcentagem):
	# "/" retorna um valor float de uma divisão
	# "//" retorna um valor inteiro(arredondado para baixo) de uma divisão
	percent = porcentagem * len(dataset) // 100
	# Gera o dataset de treino
	data_treino = random.sample(dataset, percent)
	# Gera o dataset de teste com o que sobra
	data_test = [data for data in dataset if data not in data_treino]

	# Montar um dataset, tanto treino quanto teste
	def montar(dataset):
	# x = dataset das variaveis
	# y = dataset de resultado
	x, y= [], []
	for data in dataset:
	# Pegar as variaveis atributo do dataset
	# das colunas 1 e 2
	x.append(data[1:3])
	# Pegar o atributo alvo
	# da columa 0
	y.append(data[0])
	return x, y

	x_train, y_train = montar(data_treino)
	x_test, y_test = montar(data_test)

	return x_train, y_train, x_test, y_test

	x_treino, y_treino, x_teste, y_teste = treino_test_split(dataset, 80)

	# Funcao sinal
	def sinal(u):
	return 1 if u >= 0 else -1

	# w = Peso (bias)
	# x = Linha
	# d = Saida original
	# y = Saida treinada
	def ajuste(w, x, d, y):
	# A taxa precisa ser um valor entre 0 e 1
	taxa_aprendizagem = 0.01
	return w + taxa_aprendizagem * (d-y) * x

	# Treino
	# x = Conjunto de amostras de treinamento
	# d = Valor desejado para cada amostra
	def perceptron_fit(x, d):
	# Limite de "convergencia"
	# Se a rede demorar muito para convergir
	# usa para limitar a rede
	# EX: Se demorar 1000 ou mais, é limitada
	epoca = 0
	# Pesos
	# Três numeros aleatorios entre 0 e 1
	w = [random.random() for i in range(3)]
	print(w)

	while True:
	erro = False
	# Criar a iteração sobre o x
	for i in range(len(x)):
	# "w[0]" é o bias
	u = sum([w[0]-1, w[1]x[i][0], w[2]*x[i][1]])
	# Receber o valor do sinal de u
	y = sinal(u)
	# Se a saida treinada for diferente da esperada
	if y != d[i]:
	w[0] = ajuste(w[0], -1, d[i], y)
	w[1] = ajuste(w[1], x[i][0], d[i], y)
	w[2] = ajuste(w[2], x[i][1], d[i], y)
	# O erro aconteceu
	# A rede esta falha
	erro = True
	epoca += 1
	if erro is False or epoca == 1000:
	break
	print("Épocas: " + str(epoca))
	return w

	w_fit = perceptron_fit(x_treino, y_treino)
	print(w_fit)

	# Validacao dos dados
	def perceptron_predict(x_teste, w_ajustado):
	y_predict = []
	# Iterar sobre o dataset
	for i in range(len(x_teste)):
	predict = sum([w_ajustado[0]-1, w_ajustado[1]x_teste[i][0], w_ajustado[2]*x_teste[i][1]])
	y_predict.append(sinal(predict))
	return y_predict

	y_validado = perceptron_predict(x_teste, w_fit)
	print(y_validado)

	# Quanto a rede foi boa em predizer
	def acuracia(y_teste, y_validado):
	total_acertos = 0
	for i in range(len(y_teste)):
	if y_teste[i] == y_validado[i]:
	total_acertos += 1
	else:
	pass
	# Total de acertos pelo total de amostras
	return total_acertos/len(y_validado)

	accuracy = acuracia(y_teste, y_validado)
	print(accuracy)
	#!/usr/bin/python3
	# -- coding: utf-8 --

	# Redes neurais com as bibliotecas pandas e scikit-learn
	# treinamento e predição de um perceptron simples

	# trabalhar com elementos lineares
	from sklearn import linear_model
	# selection para fazer o train_test_split
	from sklearn import model_selection
	# metrics para pegar acuracia
	from sklearn import metrics
	# pandas para encurtar os dados
	import pandas as pd

	file_path = "CVS/File/Path"

	dataset = pd.read_csv(file_path)
	# pegar todos os valores de todas as linhas
	# pegar todos os valores da coluna 1 e adiante
	x = dataset.iloc[:, 1:].values
	# pegar valores alvo da primeira coluna
	y = dataset.iloc[:, 0].values

	# Criar o perceptron
	perceptron = linear_model.Perceptron()

	# Dividir os dados es teste e treino
	x_train, x_test, y_train, y_test = model_selection.train_test_split(x, y, test_size=0.2, random_state=0)

	# Treinar dados
	classificador = perceptron.fit(x_train, y_train)
	# Predizer dados
	y_predict = classificador.predict(x_test)

	# Exibit acurácia da predição
	print(metrics.accuracy_score(y_test, y_predict))