#!/usr/bin/env python
# coding: utf-8

# In[32]:


import pandas as pd
pd.set_option('display.max_columns', 100)
pd.set_option('display.max_rows', 100)
import numpy as np
import missingno
print('Pandas')

#Like jupyter notebook
from IPython.display import display
print('Ipython')

#Use for ploting 
import matplotlib.pyplot as plt
#matplotlib inline
import seaborn as sns
import plotly.express as px
print('Matplotlib')

#Model Junk
import torch
from torch import nn
from torch.autograd import Variable
from torch.utils.data import DataLoader, TensorDataset
print('PyFlashight')

from sklearn.model_selection import train_test_split

print('All Imported')


# In[33]:


# Prepare Dataset
# load data

df = pd.read_csv('../AGENA-TARGET_1966-065A.csv')
practice_df1 = df[['MEAN_MOTION', 'PERIOD']]
practice_df2 = df[['ECCENTRICITY']]
#print(practice_df1)

train = practice_df1.to_numpy(dtype = np.float32)
feature = practice_df2.to_numpy(dtype = np.float32)
#df = pd.read_csv('../AGENA-TARGET_1966-065A.csv')
#train = df[['MEAN_MOTION', 'PERIOD']]

#train = pd.read_csv('../AGENA-TARGET_1966-065A.csv')
         
targets_numpy = train
#targets_numpy = practice_df1.MEAN_MOTION.values
print(targets_numpy)
features_numpy = feature
print('---------------------------------------')
print(features_numpy)
#features_numpy = train.loc[:,train.columns != "MEAN_MOTION"].values/255 # normalization

# train test split. Size of train data is 80% and size of test data is 20%. 
features_train, features_test, targets_train, targets_test = train_test_split(features_numpy,
                                                                             targets_numpy,
                                                                             test_size = 0.2,
                                                                             random_state = 42) 

# create feature and targets tensor for train set. As you remember we need variable to accumulate gradients. Therefore first we create tensor, then we will create variable
featuresTrain = torch.from_numpy(features_train)
targetsTrain = torch.from_numpy(targets_train)

# create feature and targets tensor for test set.
featuresTest = torch.from_numpy(features_test)
targetsTest = torch.from_numpy(targets_test)

# batch_size, epoch and iteration
batch_size = 100
n_iters = 10000
num_epochs = n_iters / (len(features_train) / batch_size)
num_epochs = int(num_epochs)

# Pytorch train and test sets
train = TensorDataset(featuresTrain,targetsTrain)
test = TensorDataset(featuresTest,targetsTest)

# data loader
train_loader = DataLoader(train, batch_size = batch_size, shuffle = False)
test_loader = DataLoader(test, batch_size = batch_size, shuffle = False)


# In[43]:


class RNNModel(nn.Module):
    def __init__(self, input_dim, hidden_dim, layer_dim, output_dim):
        super(RNNModel, self).__init__()
        
        # Number of hidden dimensions
        self.hidden_dim = hidden_dim
        
        # Number of hidden layers
        self.layer_dim = layer_dim
        
        # RNN
        self.rnn = nn.RNN(input_dim, hidden_dim, layer_dim, batch_first=True, nonlinearity='relu')
        
        # Readout layer
        self.fc = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, x):
        
        # Initialize hidden state with zeros
       # h1 = np.array([1, 1, 100])
       # h0 = torch.from_numpy(h1)

        h0 = Variable(torch.zeros(self.layer_dim, x.size(0),  self.hidden_dim))
                
       # print(h0.dim())
       # print(h0)
       # print('-----------------------')
       # print(x)
       # print(self.hidden_dim)
                                  
        #One time step
        out, hn = self.rnn(x, h0)
        out = self.fc(out[:,-1, :]) 
        #print(out.dim())
        return out

# batch_size, epoch and iteration
batch_size = 100
n_iters = 10000
num_epochs = n_iters / (len(features_train) / batch_size)
num_epochs = int(num_epochs)

# Pytorch train and test sets
train = TensorDataset(featuresTrain,targetsTrain)
test = TensorDataset(featuresTest,targetsTest)

# data loader
train_loader = DataLoader(train, batch_size = batch_size, shuffle = False)
test_loader = DataLoader(test, batch_size = batch_size, shuffle = False)
    
# Create RNN
input_dim = 2    # input dimension
hidden_dim = 100  # hidden layer dimension
layer_dim = 1     # number of hidden layers
output_dim = 10   # output dimension

model = RNNModel(input_dim, hidden_dim, layer_dim, output_dim)

# Cross Entropy Loss 
error = nn.CrossEntropyLoss()

# SGD Optimizer
learning_rate = 0.05
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)


# In[45]:


seq_dim = 116 
loss_list = []
iteration_list = []
accuracy_list = []
count = 0
for epoch in range(num_epochs):
    for i, (numbers, labels) in enumerate(train_loader):

        train  = Variable(labels.view(-1, seq_dim, input_dim)) 
        labels = Variable(labels)

        #print('Training Data is',train.dim())

        #print('Testing Data is', labels.dim())
        
            
        # Clear gradients
        optimizer.zero_grad()

        #print('Training Data is',train.dim())

        #print('Testing Data is', labels.dim())

        
        # Forward propagation
        outputs = model(train)
        print(outputs)
        print(labels)

        print(outputs.dim())
        print(labels.dim())

        # Calculate softmax and ross entropy loss
        #loss = error(outputs, labels)
        
        # Calculating gradients
        #loss.backward()
        
        # Update parameters
        optimizer.step()
        
        count += 1
        
        if count % 250 == 0:
            # Calculate Accuracy         
            correct = 0
            total = 0
            # Iterate through test dataset
            for numbers, labels in test_loader:
               numbers = Variable(numbers.view(-1, seq_dim, input_dim))
                
               # Forward propagation
               outputs = model(numbers)
               
               # Get predictions from the maximum value
               predicted = torch.max(outputs.data, 1)[1]
               
               # Total number of labels
               total += labels.size(0)
               
               correct += (predicted == labels).sum()
               
            accuracy = 100 * correct / float(total)
            
            # store loss and iteration
            #loss_list.append(loss.data)
            iteration_list.append(count)
            accuracy_list.append(accuracy)
            if count % 500 == 0:
                # Print Loss
                print('Iteration: {}  Accuracy: {} %'.format(count, accuracy))


# In[ ]: