TimeSeriesPrediction

from sklearn import linear_model
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import csv
from pandas import Series
from sklearn.metrics import mean_squared_error
from statsmodels.tsa.api import ExponentialSmoothing, SimpleExpSmoothing, Holt

import os
from timeit import default_timer as timer



#df = pd.read_excel('Original.xlsx')

#input_var = input("Enter Values for TransmissionTime,UpdateTime,ConsecutiveMessageLost\nPlease separate them with ',': ")
#print ("you entered " + input_var)

TTVValue = 0.7
UTVValue = 0.5
CMLVValue = 0.3

global UpStateFunction


def MakeUpStateFunction():

    global UpStateFunction
    UpStateFunction = []

    TT = []
    UT = []
    CML = []
    TI  = []
    AbsTTTI = []

    NTT=[]
    NUT=[]
    NCML=[]

    with open('Original.csv','r',encoding="UTF8") as csvfile:
        csvreader = csv.reader(csvfile,delimiter=',')
        csvreader = csv.reader((x.replace('\0', '') for x in csvfile))
        #str = str.unicode(str, errors='ignore')
        next(csvreader, None)
        for row in csvreader:
            if(row):
                TT.append(row[0])
                UT.append(row[1])
                CML.append(row[2])
                TI.append(row[3])
                AbsTTTI.append(np.absolute(float(row[1]) - float(row[3])))




    x = np.asarray(TT, dtype='float64')
    TTAlpha = min(TT)
    TTBeta = np.percentile(x, 99)

    UTAlpha = 0
    UTBeta = np.var(AbsTTTI)

    CMLAlpha = 0
    CMLBeta = 3

#---------------------Normalize Transmission Time----------------------------------------------------------------
    for i in range(0,len(x)):
        if(x[i] <= float(TTAlpha)):
            NTT.append(1)
        if(x[i] > float(TTAlpha) and x[i] < float(TTBeta)):
            NTT.append(1-(x[i]-float(TTAlpha))/(float(TTBeta)-float(TTAlpha)))
        if(x[i] >= float(TTBeta)):
            NTT.append(0)

#-----------------------Normalize Update Time---------------------------------------------------------------------
    for i in range(0, len(AbsTTTI)):
        if (AbsTTTI[i] <= float(UTAlpha)):
            NUT.append(1)
        if (AbsTTTI[i] > float(UTAlpha) and AbsTTTI[i] < float(UTBeta)):
            NUT.append(1 - (AbsTTTI[i] - float(UTAlpha)) / (float(UTBeta) - float(UTAlpha)))
        if (AbsTTTI[i] >= float(UTBeta)):
            NUT.append(0)
#-------------------------Normalize Consecutive Message Lost--------------------------------------------------------
    for i in range(0, len(CML)):
        if (float(CML[i]) <= float(CMLAlpha)):
            NCML.append(1)
        if (float(CML[i]) > float(CMLAlpha) and float(CML[i]) < float(CMLBeta)):
            NCML.append(1 - (float(CML[i]) - float(CMLAlpha)) / (float(CMLBeta) - float(CMLAlpha)))
        if (float(CML[i]) >= float(CMLBeta)):
            NCML.append(0)
#-------------------------Generating Up-State-Function----------------------------------------------------------------

    for i in range(0,len(NTT)):
        UpStateFunction.append(1/(TTVValue+UTVValue+CMLVValue)*((TTVValue*float(NTT[i]))+(UTVValue*float(NUT[i]))+(CMLVValue*float(NCML[i]))))


    ls = []
    st = 'Up-State-Value'
    # st=st.encode('utf-8')
    ls.append([st])
    st = ''
    with open('UpStateFunction.csv', 'w', encoding='UTF8', newline='') as csvfile:
        wr = csv.writer(csvfile)
        for k in range(0, len(UpStateFunction) - 1):
            st = UpStateFunction[k]
            ls.append([st])
        wr.writerows(ls)

#-------------------------------------------------End of MakeUpStateFunction------------------------------------------------

def MovingAverageMethod():

    global UpStateFunction
    PredictionList = []
    data = pd.read_csv('UpStateFunction.csv',sep='\t')
    df = pd.DataFrame(data)
    arr=df.rolling(window=3).mean()
    for i in range(2,len(arr)):
        PredictionList.append(arr.iloc[i][0])

    ls = []
    st = 'MovingAverageValue'
    # st=st.encode('utf-8')
    ls.append([st])
    st = ''
    with open('MovingAverageMethod.csv', 'w', encoding='UTF8', newline='') as csvfile:
        wr = csv.writer(csvfile)
        for k in range(0, len(arr)):
            st = arr.iloc[k][0]
            ls.append([st])
        wr.writerows(ls)

    expected = UpStateFunction
    del expected[0]
    del expected[1]
    del expected[2]

    mse = mean_squared_error(expected, PredictionList)
    rmse = np.sqrt(mse)
    print('RMSE of moving average method: %f' % rmse)

#-----------------------------------------------------------------------------------------------------------------------------
def MakeSimpleExponentialSmoothing():

    # prepare data
    data = pd.read_csv('UpStateFunction.csv', sep='\t')
    # create class
    model = SimpleExpSmoothing(data)
    # fit model
    model = model.fit(smoothing_level=0.3)
    # make prediction
    result = model.predict(0, len(data))

    PredictionList = []
    ls = []
    st = 'SimpleExponencialSmoothingValue'
    # st=st.encode('utf-8')
    ls.append([st])
    st = ''
    with open('SimpleExponencialSmoothing.csv', 'w', encoding='UTF8', newline='') as csvfile:
        wr = csv.writer(csvfile)
        for k in range(0, len(result)-1):
            st = result[k]
            #print(st)
            PredictionList.append(st)
            ls.append([st])
        wr.writerows(ls)

    mse = mean_squared_error(data, PredictionList)
    rmse = np.sqrt(mse)
    print('RMSE of simple exponencial smoothing: %f' % rmse)


#------------------------------------------------------------------------------------------------------------------------------
def MakelinearExponentialSmoothing():
    # prepare data
    data = pd.read_csv('UpStateFunction.csv', sep='\t')
    # create class
    model = ExponentialSmoothing(data)
    # fit model
    model = model.fit()
    # make prediction
    result = model.predict(0, len(data))

    PredictionList = []
    ls = []
    st = 'LinearExponencialSmoothingValue'
    # st=st.encode('utf-8')
    ls.append([st])
    st = ''
    with open('LinearExponencialSmoothing.csv', 'w', encoding='UTF8', newline='') as csvfile:
        wr = csv.writer(csvfile)
        for k in range(0, len(result) - 1):
            st = result[k]
            # print(st)
            PredictionList.append(st)
            ls.append([st])
        wr.writerows(ls)

    mse = mean_squared_error(data, PredictionList)
    rmse = np.sqrt(mse)
    print('RMSE of linear exponencial smoothing: %f' % rmse)


#------------------------------------------------------------------------------------------------------------------------------
MakeUpStateFunction()
MovingAverageMethod()
MakeSimpleExponentialSmoothing()
MakelinearExponentialSmoothing()