Demo entry 6754360

ML

   

Submitted by anonymous on Jul 10, 2018 at 20:04
Language: Python 3. Code size: 5.1 kB.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Importando os dados e armazenando em um dataframe
df = pd.read_csv('dataset/data_stocks.csv')

# Descartando a coluna 'DATE'
df = df.drop(['DATE'], 1)

# Salvando as dimensões da tabela nas variáveis m e n:
n = df.shape[0] # Numero de linhas
m = df.shape[1] # Numero de colunas

# Criando um numpy array a partir do dataframe:
data = df.values

# Separando dados de treino e de testee:
treino_ini = 0
treino_fim = int(np.floor(0.8*n))

teste_ini = treino_fim
teste_fim = n

dados_treino = data[np.arange(treino_ini, treino_fim),:]
dados_teste = data[np.arange(teste_ini, teste_fim),:]



"""
	Escalando os Dados 
	Escalar os dados ajuda no desempenho da maioria das arquiteturas de rede neural, porque as funções de ativação normalmente são definidas entre [-1,1] ou [0,1]
"""

from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
print(scaler)

#Define o menor valor de dados_treino como 0 e o maior como 1:
scaler.fit(dados_treino)

#Escala os dados de treino e de testee:
dados_treino = scaler.transform(dados_treino)
dados_teste = scaler.transform(dados_teste)



"""
	Definindo os Conjuntos de Dados de entrada 'X' e saída 'y'
"""
X_treino = dados_treino[:, 1:]
y_treino = dados_treino[:, 0]
X_teste = dados_teste[:, 1:]
y_teste = dados_teste[:, 0]



"""
	Arquitetura da Rede Neural
"""

# Importando biblioteca TensorFlow
import tensorflow as tf



# Parâmetros da arquitetura do modelo
n_stocks = 500 # Quantidade de constituíntes (ações por linha)

# Quantidade de Neurons por camada:
n_neurons_1 = 1024 # O dobro da quantidade de ações
n_neurons_2 = 512
n_neurons_3 = 256
n_neurons_4 = 128

n_target = 1 # Saída é um único valor (Índice S&P calculado)


# Session:
net = tf.InteractiveSession()

# Placeholder
X = tf.placeholder(dtype=tf.float32, shape=[None, n_stocks])
Y = tf.placeholder(dtype=tf.float32, shape=[None])



# Inicializando pesos e bias
sigma = 1
weight_initializer = tf.variance_scaling_initializer(mode="fan_avg", distribution="uniform", scale=sigma)
bias_initializer = tf.zeros_initializer()



# Camada 1:
W_hidden_1 = tf.Variable(weight_initializer([n_stocks, n_neurons_1]))
bias_hidden_1 = tf.Variable(bias_initializer([n_neurons_1]))

# Camada 2:
W_hidden_2 = tf.Variable(weight_initializer([n_neurons_1, n_neurons_2]))
bias_hidden_2 = tf.Variable(bias_initializer([n_neurons_2]))

# Camada 3:
W_hidden_3 = tf.Variable(weight_initializer([n_neurons_2, n_neurons_3]))
bias_hidden_3 = tf.Variable(bias_initializer([n_neurons_3]))

# Camada 4:
W_hidden_4 = tf.Variable(weight_initializer([n_neurons_3, n_neurons_4]))
bias_hidden_4 = tf.Variable(bias_initializer([n_neurons_4]))

# Camada de Saída:
W_out = tf.Variable(weight_initializer([n_neurons_4, n_target]))
bias_out = tf.Variable(bias_initializer([n_target]))



"""
	Definindo cálculos das Camadas:
"""

# Camada oculta:
hidden_1 = tf.nn.relu(tf.add(tf.matmul(X, W_hidden_1), bias_hidden_1))
hidden_2 = tf.nn.relu(tf.add(tf.matmul(hidden_1, W_hidden_2), bias_hidden_2))
hidden_3 = tf.nn.relu(tf.add(tf.matmul(hidden_2, W_hidden_3), bias_hidden_3))
hidden_4 = tf.nn.relu(tf.add(tf.matmul(hidden_3, W_hidden_4), bias_hidden_4))

# Camada de Saída:
out = tf.transpose(tf.add(tf.matmul(hidden_4, W_out), bias_out))


# Erro:
mse = tf.reduce_mean(tf.squared_difference(out, Y))

# Otimizador de erro:
opt = tf.train.AdamOptimizer().minimize(mse)



"""
	Ajustando Rede Neural (Realizando Aprendizagem e Validação)
"""


# Executando inicializadores:
net.run(tf.global_variables_initializer())



# Configurando plot interativo:
plt.ion()
fig = plt.figure()
ax1 = fig.add_subplot(111)
line1, = ax1.plot(y_teste)
line2, = ax1.plot(y_teste*0.5)
plt.show()



# Número de épocas e execuções por época:
epochs = 10
batch_size = 256
mse_train = []
mse_test = []


#Aprendizagem:
for e in range(epochs):

    # Permutando dados de treino:
    shuffle_indices = np.random.permutation(np.arange(len(y_treino)))
    X_treino = X_treino[shuffle_indices]
    y_treino = y_treino[shuffle_indices]

    # Treinamento:
    for i in range(0, len(y_treino) // batch_size):
        start = i * batch_size
        batch_x = X_treino[start:start + batch_size]
        batch_y = y_treino[start:start + batch_size]

        net.run(opt, feed_dict={X: batch_x, Y: batch_y})

        # Mostrar progresso:
        if np.mod(i, 5) == 0:
            # Predição:
            print('Epoch ' + str(e) + ', Batch ' + str(i))
            mse_train.append(net.run(mse, feed_dict={X: X_treino, Y: y_treino}))
            mse_test.append(net.run(mse, feed_dict={X: X_teste, Y: y_teste}))
            print('MSE Train: ', mse_train[-1])
            print('MSE Test: ', mse_test[-1])
            # Prediction
            pred = net.run(out, feed_dict={X: X_teste})
            line2.set_ydata(pred)
            plt.title('Epoch ' + str(e) + ', Batch ' + str(i))
            plt.pause(0.01)

This snippet took 0.01 seconds to highlight.

Back to the Entry List or Home.

Delete this entry (admin only).