myawesomepkg 0.1.3__tar.gz → 0.1.4__tar.gz

myawesomepkg-0.1.4/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: myawesomepkg
+Version: 0.1.4
+Summary: A simple greeting library
+Author: Your Name
+Author-email: your.email@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

myawesomepkg-0.1.4/myawesomepkg/TSAPY1/practical_no_3.py

@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+"""Practical No 3.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1aCeoKiFV3QbdraoAWb562bOjZDdBw0be
+
+## **Practical No 3:**
+# Aim: Detrending, deseasonalizing timeseries, detecting Cyclic variations and decomposing Time Series.
+
+## Trend
+"""
+
+# Commented out IPython magic to ensure Python compatibility.
+import pandas as pd
+# %matplotlib inline
+from statsmodels.tsa.filters.hp_filter import hpfilter
+df = pd.read_excel(r'/content/drive/MyDrive/MScDS TSA/India_Exchange_Rate_Dataset.xls',index_col=0,parse_dates=True)
+EXINUS_cycle,EXINUS_trend = hpfilter(df['EXINUS'], lamb=1600)
+EXINUS_trend.plot(figsize=(15,6)).autoscale(axis='x',tight=True)
+
+"""**Detrending using Differencing**"""
+
+# Commented out IPython magic to ensure Python compatibility.
+import pandas as pd
+import matplotlib.pyplot as plt
+import warnings
+warnings.filterwarnings("ignore")
+# %matplotlib inline
+df = pd.read_excel(r'/content/drive/MyDrive/MScDS TSA/India_Exchange_Rate_Dataset.xls',index_col=0,parse_dates=True)
+diff = df.EXINUS.diff()
+plt.figure(figsize=(15,6))
+plt.plot(diff)
+plt.title('Detrending using Differencing', fontsize=16)
+plt.xlabel('Year')
+plt.ylabel('EXINUS exchange rate')
+plt.show()
+
+"""** **bold text**Detrending using Scipy Signal**"""
+
+# Commented out IPython magic to ensure Python compatibility.
+import pandas as pd
+import matplotlib.pyplot as plt
+from scipy import signal
+import warnings
+warnings.filterwarnings("ignore")
+# %matplotlib inline
+df = pd.read_excel(r'/content/drive/MyDrive/MScDS TSA/India_Exchange_Rate_Dataset.xls',index_col=0,parse_dates=True)
+detrended = signal.detrend(df.EXINUS.values)
+plt.figure(figsize=(15,6))
+plt.plot(detrended)
+plt.xlabel('EXINUS')
+plt.ylabel('Frequency')
+plt.title('Detrending using Scipy Signal', fontsize=16)
+plt.show()
+
+"""**Detrending using HP Filter**"""
+
+# Commented out IPython magic to ensure Python compatibility.
+import pandas as pd
+import matplotlib.pyplot as plt
+from statsmodels.tsa.filters.hp_filter import hpfilter
+import warnings
+warnings.filterwarnings("ignore")
+# %matplotlib inline
+df = pd.read_excel(r'/content/drive/MyDrive/MScDS TSA/India_Exchange_Rate_Dataset.xls',index_col=0,parse_dates=True)
+EXINUS_cycle,EXINUS_trend = hpfilter(df['EXINUS'], lamb=1600)
+df['trend'] = EXINUS_trend
+detrended = df.EXINUS - df['trend']
+plt.figure(figsize=(15,6))
+plt.plot(detrended)
+plt.title('Detrending using HP Filter', fontsize=16)
+plt.xlabel('Year')
+plt.ylabel('EXINUS exchange rate')
+plt.show()
+
+"""## Seasonality
+
+Methods can be used to detect seasonality:
+a. Multiple box plots
+b. Autocorrelation plots
+
+A. **Multi Month-wise Box Plot**
+"""
+
+# Commented out IPython magic to ensure Python compatibility.
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+from statsmodels.tsa.filters.hp_filter import hpfilter
+import warnings
+warnings.filterwarnings("ignore")
+# %matplotlib inline
+df = pd.read_excel(r'/content/drive/MyDrive/MScDS TSA/India_Exchange_Rate_Dataset.xls',parse_dates=True)
+df['month'] = df['observation_date'].dt.strftime('%b')
+df['year'] = [d.year for d in df.observation_date]
+df['month'] = [d.strftime('%b') for d in df.observation_date]
+years = df['year'].unique()
+plt.figure(figsize=(15,6))
+sns.boxplot(x='month', y='EXINUS', data=df).set_title("Multi Month-wise Box Plot")
+plt.show()
+
+"""B. **Autocorrelation plot for seasonality**"""
+
+# Commented out IPython magic to ensure Python compatibility.
+from pandas.plotting import autocorrelation_plot
+import pandas as pd
+import matplotlib.pyplot as plt
+# %matplotlib inline
+df = pd.read_excel(r'/content/drive/MyDrive/MScDS TSA/India_Exchange_Rate_Dataset.xls',index_col=0,parse_dates=True)
+#plt.rcParams.update({'figure.figsize':(15,6), 'figure.dpi':220})
+autocorrelation_plot(df.EXINUS.tolist())
+
+"""**Deseasoning Time series**"""
+
+# Commented out IPython magic to ensure Python compatibility.
+import pandas as pd
+import matplotlib.pyplot as plt
+from statsmodels.tsa.seasonal import seasonal_decompose
+import warnings
+warnings.filterwarnings("ignore")
+# %matplotlib inline
+df = pd.read_excel(r'/content/drive/MyDrive/MScDS TSA/India_Exchange_Rate_Dataset.xls',index_col=0,parse_dates=True)
+result_mul = seasonal_decompose(df['EXINUS'], model='multiplicative', extrapolate_trend='freq')
+deseason = df['EXINUS'] - result_mul.seasonal
+plt.figure(figsize=(15,6))
+plt.plot(deseason)
+plt.title('Deseasoning using seasonal_decompose', fontsize=16)
+plt.xlabel('Year')
+plt.ylabel('EXINUS exchange rate')
+plt.show()
+
+"""**Detecting cyclical variation**"""
+
+# Commented out IPython magic to ensure Python compatibility.
+from statsmodels.tsa.filters.hp_filter import hpfilter
+import pandas as pd
+import matplotlib.pyplot as plt
+import warnings
+warnings.filterwarnings("ignore")
+# %matplotlib inline
+df = pd.read_excel(r'/content/drive/MyDrive/MScDS TSA/India_Exchange_Rate_Dataset.xls',index_col=0,parse_dates=True)
+EXINUS_cycle,EXINUS_trend = hpfilter(df['EXINUS'], lamb=1600)
+df['cycle'] =EXINUS_cycle
+df['trend'] =EXINUS_trend
+df[['cycle']].plot(figsize=(15,6)).autoscale(axis='x',tight=True)
+plt.title('Extracting Cyclic Variations', fontsize=16)
+plt.xlabel('Year')
+plt.ylabel('EXINUS exchange rate')
+plt.show()
+
+"""**Decompose Time series**"""
+
+# Commented out IPython magic to ensure Python compatibility.
+from statsmodels.tsa.seasonal import seasonal_decompose
+import pandas as pd
+import matplotlib.pyplot as plt
+import warnings
+warnings.filterwarnings("ignore")
+# %matplotlib inline
+df = pd.read_excel(r'/content/drive/MyDrive/MScDS TSA/India_Exchange_Rate_Dataset.xls',
+index_col=0,parse_dates=True)
+result = seasonal_decompose(df['EXINUS'], model='add')
+result.plot();
+result = seasonal_decompose(df['EXINUS'], model='mul')
+result.plot();

myawesomepkg-0.1.4/myawesomepkg/TSAPY1/practical_no_4.py

@@ -0,0 +1,215 @@
+# -*- coding: utf-8 -*-
+"""Practical No 4.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1DnqwmMcr1ypxLue43og-x_3DEDaI1g7Q
+
+# Aim: Working with stationary and non stationary timeseries
+
+# Checks for Stationarity
+There are many methods to check whether a time series (direct observations, residuals, otherwise)
+is stationary or non-stationary.
+
+**A] Look at Plots:** You can review a time series plot of your data and visually check if there are any obvious trends or seasonality.
+
+**Stationary Time Series**
+"""
+
+# load time series data
+from pandas import read_csv
+from matplotlib import pyplot
+series = read_csv('/content/drive/MyDrive/MScDS TSA/daily-total-female-births.csv', header=0, index_col=0, parse_dates=True,
+squeeze=True)
+series.plot()
+pyplot.show()
+
+"""**Non-Stationary Time Series**"""
+
+# load time series data
+from pandas import read_csv
+from matplotlib import pyplot
+series = read_csv('/content/drive/MyDrive/MScDS TSA/AirPassengers.csv', header=0, index_col=0, parse_dates=True,
+squeeze=True)
+series.plot()
+pyplot.show()
+
+"""**B] Summary Statistics:** You can review the summary statistics for your data for seasons or random partitions and check for obvious or significant differences
+
+
+"""
+
+# plot a histogram of a time series
+from pandas import read_csv
+from matplotlib import pyplot
+series = read_csv('/content/drive/MyDrive/MScDS TSA/daily-total-female-births.csv', header=0, index_col=0, parse_dates=True,
+squeeze=True)
+series.hist()
+pyplot.show()
+
+"""We clearly see the bell curve-like shape of the Gaussian distribution, perhaps with a longer right tail.
+
+we can split the time series into two contiguous sequences. We can then calculate the mean and variance of each group of numbers and compare the values.
+"""
+
+# calculate statistics of partitioned time series data
+from pandas import read_csv
+series = read_csv('/content/drive/MyDrive/MScDS TSA/daily-total-female-births.csv', header=0, index_col=0, parse_dates=True,squeeze=True)
+
+X = series
+2))
+
+"""This example shows that the mean and variance values are different, but in the
+same ball-park(range).
+"""
+
+# calculate statistics of partitioned time series data
+from pandas import read_csv
+series = read_csv('/content/drive/MyDrive/MScDS TSA/AirPassengers.csv', header=0, index_col=0, parse_dates=True,
+squeeze=True)
+X = series.values
+split = int(len(X) / 2)
+X1, X2 = X[0:split], X[split:]
+mean1, mean2 = X1.mean(), X2.mean()
+var1, var2 = X1.var(), X2.var()
+print('mean1=%f, mean2=%f' % (mean1, mean2))
+print('variance1=%f, variance2=%f' % (var1, var2))
+
+"""The example, we can see the mean and variance look very different. We have a
+non-stationary time series.
+
+**C] Statistical Tests:** You can use statistical tests to check if the expectations of stationarity are met or have been violated
+
+Calculating the Augmented Dickey-Fuller test on the Daily Female Births dataset.
+"""
+
+# calculate stationarity test of time series data
+from pandas import read_csv
+from statsmodels.tsa.stattools import adfuller
+series = read_csv('/content/drive/MyDrive/MScDS TSA/daily-total-female-births.csv', header=0, index_col=0, parse_dates=True,
+squeeze=True)
+X = series.values
+result = adfuller(X)
+print('ADF Statistic: %f' % result[0])
+print('p-value: %f' % result[1])
+print('Critical Values:')
+for key, value in result[4].items():
+  print('\t%s: %.3f' % (key, value))
+
+"""Running the example prints the test statistic value of -4. The more negative this statistic,
+the more likely we are to reject the null hypothesis (we have a stationary dataset). As part of
+the output, we get a look-up table to help determine the ADF statistic. We can see that our
+statistic value of -4 is less than the value of -3.449 at 1%.
+This suggests that we can reject the null hypothesis with a significance level of less than 1%
+(i.e. a low probability that the result is a statistical fluke). Rejecting the null hypothesis means
+that the process has no unit root, and in turn that the time series is stationary or does not have
+time-dependent structure.
+
+"""
+
+#Importing the libraries:
+
+from statsmodels.tsa.stattools import adfuller
+import pandas as pd
+import numpy as np
+
+#Reading the airline-passengers data
+
+data = pd.read_csv('/content/drive/MyDrive/MScDS TSA/AirPassengers.csv', index_col='Month')
+
+#Checking for some values of the data.
+
+data.head()
+
+#Plotting the data.
+
+data.plot(figsize=(14,8), title='data series')
+
+#Taking out the passengers number as a series.
+
+series = data['#Passengers'].values
+#print(series)
+
+#Performing the ADF test on the series:
+
+# ADF Test
+result = adfuller(series, autolag='AIC')
+#Extracting the values from the results:
+
+print('ADF Statistic: %f' % result[0])
+
+print('p-value: %f' % result[1])
+
+print('Critical Values:')
+
+for key, value in result[4].items():
+    print('\t%s: %.3f' % (key, value))
+if result[0] < result[4]["5%"]:
+    print ("Reject Ho - Time Series is Stationary")
+else:
+    print ("Failed to Reject Ho - Time Series is Non-Stationary")
+
+"""The test statistic is positive,
+meaning we are much less likely to reject the null hypothesis (it looks non-stationary). Comparing
+the test statistic to the critical values, it looks like we would have to fail to reject the null
+hypothesis that the time series is non-stationary and does have time-dependent structure.
+
+"""
+
+#Kwiatkowski Phillips Schmidt Shin (KPSS) test:
+
+#Importing the libraries:
+
+from statsmodels.tsa.stattools import kpss
+import pandas as pd
+import numpy as np
+import warnings
+warnings.filterwarnings("ignore")
+
+result_kpss_ct=kpss(series,regression="ct")
+print('Test Statistic: %f' %result_kpss_ct[0])
+print('p-value: %f' %result_kpss_ct[1])
+print('Critical values:')
+for key, value in result_kpss_ct[3].items():
+     print('\t%s: %.3f' %(key, value))
+
+"""As the test statistics value is greater than the critical value, the null hypothesis is rejected. This indicates that the data is non-stationary."""
+
+#Loading the data.
+
+path = '/content/daily-min-temperatures.csv'
+data = pd.read_csv(path, index_col='Date')
+
+#Checking for some head values of the data:
+
+data.head()
+
+#Plotting the data.
+
+data.plot(figsize=(14,8), title='temperature data series')
+
+#Extracting temperature in a series.
+
+series = data['Temp'].values
+series
+
+#Performing ADF test.
+
+result = adfuller(series, autolag='AIC')
+
+#Checking the results:
+
+print('ADF Statistic: %f' % result[0])
+
+print('p-value: %f' % result[1])
+
+print('Critical Values:')
+
+for key, value in result[4].items():
+    print('\t%s: %.3f' % (key, value))
+if result[0] > result[4]["5%"]:
+    print ("Reject Ho - Time Series is Stationary")
+else:
+    print ("Failed to Reject Ho - Time Series is Stationary")
+

myawesomepkg-0.1.4/myawesomepkg/TSAPY1/practical_no_4b.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+"""Practical No 4B.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1BIAOhJMWQry0k6SDmofT9ESz5f45YX4f
+"""
+
+def test_stationarity(dataFrame, var):
+  dataFrame['rollMean']=dataFrame[var].rolling(window=12).mean()
+  dataFrame['rollStd']=dataFrame[var].rolling(window=12).std()
+
+  from statsmodels.tsa.stattools import adfuller
+  import seaborn as sns
+  adfTest = adfuller(dataFrame[var], autolag='AIC')
+  stats=pd.Series(adfTest[0:4],index=['Test Statistic','p-value', '#lags used', 'number of observations used'])
+  print(stats)
+
+  for key, value in adfTest[4].items():
+    print('\t%s: %.3f' % (key, value))
+
+  sns.lineplot(data=dataFrame, x=dataFrame.index, y=var)
+  sns.lineplot(data=dataFrame, x=dataFrame.index, y='rollMean')
+  sns.lineplot(data=dataFrame, x=dataFrame.index, y='rollStd')
+
+import pandas as pd
+import numpy as np
+
+#Reading the airline-passengers data
+
+data = pd.read_csv('/content/drive/MyDrive/MScDS TSA/AirPassengers.csv', index_col='Month')
+
+#Checking for some values of the data.
+
+data.head()
+
+test_stationarity(data,'Passengers')
+
+air_df=data[['Passengers']]
+air_df.head()
+
+air_df['shift']=air_df.Passengers.shift()
+air_df['shiftDiff']=air_df.Passengers - air_df['shift']
+air_df.head()
+
+test_stationarity(air_df.dropna(),'shiftDiff')
+
+log_df=air_df[['Passengers']]
+log_df['log']=np.log(log_df['Passengers'])
+log_df.head()
+
+test_stationarity(log_df,'log')
+
+sqrt_df=air_df[['Passengers']]
+sqrt_df['sqrt']=np.sqrt(air_df['Passengers'])
+sqrt_df.head()
+
+test_stationarity(sqrt_df,'sqrt')
+
+cbrt_df=air_df[['Passengers']]
+cbrt_df['cbrt']=np.cbrt(air_df['Passengers'])
+cbrt_df.head()
+
+test_stationarity(cbrt_df,'cbrt')
+
+log_df2=log_df[['Passengers','log']]
+log_df2['log_sqrt']=np.sqrt(log_df['log'])
+log_df2.head()
+
+test_stationarity(log_df2,'log_sqrt')
+
+log_df2=log_df[['Passengers','log']]
+log_df2['log_sqrt']=np.sqrt(log_df['log'])
+log_df2['logShiftDiff']=log_df2['log_sqrt']-log_df2['log_sqrt'].shift()
+log_df2.head()
+
+test_stationarity(log_df2.dropna(),'logShiftDiff')

myawesomepkg-0.1.4/myawesomepkg/TSAPY1/practical_no_5_ac_and_pca.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+"""Practical No 5 AC and PCA.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1sGHsmswvo180eVjgUJh53fzwK1eJoZRQ
+
+# Aim: Implementing auto correlation and partial auto-correlation on timeseries
+"""
+
+
+
+# ACF plot of time series
+from pandas import read_csv
+from matplotlib import pyplot
+#from statsmodels.graphics.tsaplots import plot_acf
+from pandas.plotting import autocorrelation_plot
+series = read_csv('/content/drive/MyDrive/MScDS TSA/daily-min-temperatures.csv', header=0, index_col=0,parse_dates=True, squeeze=True)
+#plot_acf(series)
+autocorrelation_plot(series)
+pyplot.show()
+
+# zoomed-in ACF plot of time series
+from pandas import read_csv
+from matplotlib import pyplot
+from statsmodels.graphics.tsaplots import plot_acf
+series = read_csv('/content/drive/MyDrive/MScDS TSA/daily-min-temperatures.csv', header=0, index_col=0,parse_dates=True, squeeze=True)
+plot_acf(series, lags=50)
+pyplot.show()
+
+# PACF plot of time series
+from pandas import read_csv
+from matplotlib import pyplot
+from statsmodels.graphics.tsaplots import plot_pacf
+series = read_csv('/content/drive/MyDrive/MScDS TSA/daily-min-temperatures.csv', header=0, index_col=0,
+parse_dates=True, squeeze=True)
+plot_pacf(series, lags=50)
+pyplot.show()

myawesomepkg-0.1.4/myawesomepkg/TSAPY1/practical_no_6.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+"""Practical No 6.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1xuSGmR5e0t1nj5TDFB9ASYxhiG_yKZyx
+
+# Aim: Perform autoregression on time series data
+"""
+
+# create and evaluate a static autoregressive model
+from pandas import read_csv
+from matplotlib import pyplot
+from statsmodels.tsa.ar_model import AutoReg
+from sklearn.metrics import mean_squared_error
+from math import sqrt
+# load dataset
+series = read_csv('/content/drive/MyDrive/MScDS TSA/daily-min-temperatures.csv', header=0, index_col=0,parse_dates=True, squeeze=True)
+# split dataset
+X = series.values
+train, test = X[1:len(X)-7], X[len(X)-7:]
+# train autoregression
+model = AutoReg(train,30)
+model_fit = model.fit()
+print('Lag: %s' % model_fit.ar_lags)
+print('Coefficients: %s' % model_fit.params)
+# make predictions
+predictions = model_fit.predict(start=len(train), end=len(train)+len(test)-1, dynamic=False)
+for i in range(len(predictions)):
+  print('predicted=%f, expected=%f' % (predictions[i], test[i]))
+rmse = sqrt(mean_squared_error(test, predictions))
+print('Test RMSE: %.3f' % rmse)
+# plot results
+pyplot.plot(test)
+pyplot.plot(predictions, color='red')
+pyplot.show()

myawesomepkg-0.1.4/myawesomepkg/TSAPY1/practical_no_7.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+"""Practical No 7.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1rOzVCBXjN31-6HIb6h8zRRSH3R-MoGvG
+
+# Aim: Forecasting using MA model.
+"""
+
+# correct forecasts with a model of forecast residual errors
+from pandas import read_csv
+from pandas import DataFrame
+from pandas import concat
+from statsmodels.tsa.ar_model import AutoReg
+from matplotlib import pyplot
+from sklearn.metrics import mean_squared_error
+from math import sqrt
+# load data
+series = read_csv('/content/drive/MyDrive/MScDS TSA/daily-total-female-births-CA.csv', header=0, index_col=0, parse_dates=True,squeeze=True)
+# create lagged dataset
+values = DataFrame(series.values)
+dataframe = concat([values.shift(1), values], axis=1)
+dataframe.columns = ['t', 't+1']
+print(dataframe)
+X = dataframe.values
+
+# split into train and test sets
+X = dataframe.values
+train_size = int(len(X) * 0.66)
+train, test = X[1:train_size], X[train_size:]
+train_X, train_y = train[:,0], train[:,1]
+test_X, test_y = test[:,0], test[:,1]
+# persistence model on training set
+train_pred = [x for x in train_X]
+# calculate residuals
+train_resid = [train_y[i]-train_pred[i] for i in range(len(train_pred))]
+# model the training set residuals
+model = AutoReg(train_resid,20)
+model_fit = model.fit()
+window = len(model_fit.ar_lags)
+coef = model_fit.params
+# walk forward over time steps in test
+history = train_resid[len(train_resid)-window:]
+history = [history[i] for i in range(len(history))]
+predictions = list()
+for t in range(len(test_y)):
+  # persistence
+  yhat = test_X[t]
+  error = test_y[t] - yhat
+  # predict error
+  length = len(history)
+  lag = [history[i] for i in range(length-window,length)]
+  pred_error = coef[0]
+  for d in range(window):
+    pred_error += coef[d+1] * lag[window-d-1]
+  # correct the prediction
+  yhat = yhat + pred_error
+  predictions.append(yhat)
+  history.append(error)
+  print('predicted=%f, expected=%f' % (yhat, test_y[t]))
+# error
+rmse = sqrt(mean_squared_error(test_y, predictions))
+print('Test RMSE: %.3f' % rmse)
+# plot predicted error
+pyplot.plot(test_y)
+pyplot.plot(predictions, color='red')
+pyplot.show()

myawesomepkg-0.1.4/myawesomepkg/TSAPY1/practical_no_8.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+"""Practical No 8.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1Ai_ZPo-aPrKa7A_iQFtal5vinfQbYQvY
+
+# Aim: Forecasting using ARIMA model
+
+Time Series Forecasting With ARIMA Model in Python for Temperature Prediction.
+
+**1) Reading Time Series Data in Python using Pandas library**
+"""
+
+import pandas as pd
+df=pd.read_csv('/content/drive/MyDrive/MScDS TSA/MaunaLoaDailyTemps.csv',index_col='DATE',parse_dates=True)
+df=df.dropna()
+print('Shape of data',df.shape)
+df.head()
+df
+
+"""Plot Your data"""
+
+df['AvgTemp'].plot(figsize=(12,5))
+
+"""**2) Checking for stationarity of time series model**"""
+
+from statsmodels.tsa.stattools import adfuller
+def adf_test(dataset):
+     dftest = adfuller(dataset, autolag = 'AIC')
+     print("1. ADF : ",dftest[0])
+     print("2. P-Value : ", dftest[1])
+     print("3. Num Of Lags : ", dftest[2])
+     print("4. Num Of Observations Used For ADF Regression:",      dftest[3])
+     print("5. Critical Values :")
+     for key, val in dftest[4].items():
+         print("\t",key, ": ", val)
+adf_test(df['AvgTemp'])
+
+"""3) Auto Arima Function to select order of Auto Regression Model"""
+
+pip install pmdarima
+
+from pmdarima import auto_arima
+import warnings
+warnings.filterwarnings("ignore")
+stepwise_fit=auto_arima(df['AvgTemp'],trace=True,suppress_warnings=True)
+stepwise_fit.summary()
+
+"""Split Your Dataset"""
+
+print(df.shape)
+train=df.iloc[:-30]
+test=df.iloc[-30:]
+print(train.shape,test.shape)
+
+from statsmodels.tsa.arima.model import ARIMA
+model=ARIMA(train['AvgTemp'],order=(1,0,5))
+model=model.fit()
+model.summary()
+
+"""Check How Good Your Model Is"""
+
+start=len(train)
+end=len(train)+len(test)-1
+pred=model.predict(start=start,end=end,typ='levels').rename('ARIMA Predictions')
+print(pred)
+pred.index=df.index[start:end+1]
+pred.plot(legend=True)
+test['AvgTemp'].plot(legend=True)
+
+"""Check your Accuracy Metric"""
+
+from sklearn.metrics import mean_squared_error
+from math import sqrt
+test['AvgTemp'].mean()
+rmse=sqrt(mean_squared_error(pred,test['AvgTemp']))
+print(rmse)

myawesomepkg-0.1.4/myawesomepkg/TSAPY1/tsa_practical_no_1.py

@@ -0,0 +1,287 @@
+# -*- coding: utf-8 -*-
+"""TSA_Practical_No_1.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1-xNPJwhkAO4KzKFMvXII92dc9Y_VTQ8H
+
+**Practical No 1:**
+**Aim: Handling timeseries data**
+
+a. Import timeseries data
+
+b. Visualizing timeseries data using various plot
+
+# **A. Load and Explore Time Series Data**
+"""
+
+from pandas import read_csv
+series = read_csv('/content/daily-total-female-births.csv', header=0, index_col=0, parse_dates=True)
+print(type(series))
+print(series.head())
+
+"""The arguments to the **readcsv()** function. We provide it a number of hints to ensure the data is loaded as a Series.
+
+1.  **header=0:** We must specify the header information at row 0.
+2.   **parse_dates=True:** We give the function a hint that data in the first column contains dates that need to be parsed.
+3. **index_col=0:** We hint that the first column contains the index information for the time series.
+4.  **squeeze=True:** We hint that we only have one data column and that we are interested in a Series and not a DataFrame.
+
+You can use the **head()** function to peek at the first 5 records or specify the first n number of records to review
+"""
+
+print(series.head(10))
+
+"""**Number of Observations**
+You can get the dimensionality of your Series using the size parameter.
+"""
+
+print(series.size)
+
+""" **Querying By Time**
+ You can slice, dice, and query your series using the time index. For example, you can access all observations in January as follows:
+
+**series.loc[]**
+
+Access a group of rows and columns by label(s) or a boolean array.
+.loc[] is primarily label based, but may also be used with a boolean array.
+"""
+
+print(series.loc["1959-01"])
+
+"""**Descriptive Statistics**
+Calculating descriptive statistics on your time series can help get an idea of the distribution and
+spread of values.
+The **describe()** function creates
+a 7 number summary of the loaded time series including mean, standard deviation, median,
+minimum, and maximum of the observations
+"""
+
+print(series.describe())
+
+"""# **B. Data Visualization**
+Visualization plays an important role in time series analysis and forecasting. Plots of the raw
+sample data can provide valuable diagnostics to identify temporal structures like trends, cycles,
+and seasonality that can influence the choice of model. A problem is that many novices in the
+field of time series forecasting stop with line plots.
+
+Different types of visualizations that you can use on your own time series data. They are:
+1. Line Plots.
+2. Histograms and Density Plots.
+3. Box and Whisker Plots.
+4. Heat Maps.
+5. Lag Plots or Scatter Plots.
+6. Autocorrelation Plots.
+
+**Minimum Daily Temperatures Dataset**
+We will use the Minimum Daily Temperatures dataset as an example. This dataset
+describes the minimum daily temperatures over 10 years (1981-1990) in the city Melbourne,
+Australia.
+"""
+
+from pandas import read_csv
+from matplotlib import pyplot
+series = read_csv('daily-min-temperatures.csv', header=0, index_col=0,parse_dates=True)
+print(series.head())
+series=series.squeeze()
+type(series)
+print(series.describe())
+
+"""**Line Plot**
+The first, and perhaps most popular, visualization for time series is the line plot. In this plot,
+time is shown on the x-axis with observation values along the y-axis. Below is an example of
+visualizing the Pandas Series of the Minimum Daily Temperatures dataset directly as a line
+plot.
+"""
+
+series.plot()
+pyplot.show()
+
+"""Changing the style of the line to
+be black dots instead of a connected line (the style=’k.’ argument).
+"""
+
+series.plot(style='k.')
+pyplot.show()
+
+series.plot(style='k--')
+pyplot.show()
+
+"""It can be helpful to compare line plots for the same interval, such as from day-to-day,
+month-to-month, and year-to-year. The Minimum Daily Temperatures dataset spans 10
+years. We can group data by year and create a line plot for each year for direct comparison. The example below shows how to do this. First the observations are grouped by year (series.groupby(Grouper(freq=’A’))).
+
+A **Grouper** allows the user to specify a groupby instruction for an object.
+
+This specification will select a column via the key parameter, or if the level and/or axis parameters are given, a level of the index of the target object.
+
+If axis and/or level are passed as keywords to both Grouper and groupby, the values passed to Grouper take precedence
+
+The groups are then enumerated and the observations for each year are stored as columns
+in a new DataFrame. Finally, a plot of this contrived DataFrame is created with each column
+visualized as a subplot with legends removed to cut back on the clutter.
+
+The **squeeze()** method converts a single column DataFrame into a Series.
+"""
+
+from pandas import read_csv
+from pandas import DataFrame
+from pandas import Grouper
+from matplotlib import pyplot
+series = read_csv('/content/daily-min-temperatures.csv', header=0, index_col=0, parse_dates=True)
+#print(series.head())
+
+series=series.squeeze()
+#print(series.head())
+groups = series.groupby(Grouper(freq='A'))
+#print(groups)
+years = DataFrame()
+#print(years)
+for name, group in groups:
+  years[name.year] = group.values
+  print(years)
+years.plot(subplots=True, legend=False)
+pyplot.show()
+
+"""**Histogram and Density Plots**
+
+Another important visualization is of the distribution of observations themselves. This means a
+plot of the values without the temporal ordering. Some linear time series forecasting methods
+assume a well-behaved distribution of observations (i.e. a bell curve or normal distribution).
+This can be explicitly checked using tools like statistical hypothesis tests. But plots can provide
+a useful first check of the distribution of observations both on raw observations and after any
+type of data transform has been performed.
+The example below creates a histogram plot of the observations in the Minimum Daily
+Temperatures dataset. A histogram groups values into bins, and the frequency or count of
+observations in each bin can provide insight into the underlying distribution of the observations. Histograms and density plots provide insight into the distribution of all observations, but we
+may be interested in the distribution of values by time interval.
+"""
+
+series.hist()
+pyplot.show()
+
+"""Generate Kernel Density Estimate plot using Gaussian kernels."""
+
+series.plot(kind='kde')
+pyplot.show()
+
+years.boxplot()
+pyplot.show()
+
+"""**Box and Whisker Plots by Interval**
+
+ Another type of plot that is
+useful to summarize the distribution of observations is the box and whisker plot. This plot
+draws a box around the 25th and 75th percentiles of the data that captures the middle 50% of
+observations. A line is drawn at the 50th percentile (the median) and whiskers are drawn above
+and below the box to summarize the general extents of the observations. Dots are drawn for
+outliers outside the whiskers or extents of the data.
+
+Box and whisker plots can be created and compared for each interval in a time series, such
+as years, months, or days. Below is an example of grouping the Minimum Daily Temperatures
+dataset by years, as was done above in the plot example. A box and whisker plot is then created
+for each year and lined up side-by-side for direct comparison.
+
+Within an interval,
+it can help to spot outliers (dots above or below the whiskers). Across intervals, in this case
+years, we can look for multiple year trends, seasonality, and other structural information that
+could be modeled
+"""
+
+from pandas import read_csv
+from pandas import DataFrame
+from pandas import Grouper
+from matplotlib import pyplot
+series = read_csv('daily-min-temperatures.csv', header=0, index_col=0, parse_dates=True)
+series=series.squeeze()
+groups = series.groupby(Grouper(freq='A'))
+years = DataFrame()
+for name, group in groups:
+ years[name.year] = group.values
+years.boxplot()
+pyplot.show()
+
+"""**Heat Maps**
+A matrix of numbers can be plotted as a surface, where the values in each cell of the matrix are
+assigned a unique color. This is called a heatmap, as larger values can be drawn with warmer
+colors (yellows and reds) and smaller values can be drawn with cooler colors (blues and greens).
+Like the box and whisker plots, we can compare observations between intervals using a heat
+map.
+In the case of the Minimum Daily Temperatures, the observations can be arranged into a
+matrix of year-columns and day-rows, with minimum temperature in the cell for each day. A
+heat map of this matrix can then be plotted. Below is an example of creating a heatmap of
+the Minimum Daily Temperatures data. The matshow() function from the Matplotlib library
+is used as no heatmap support is provided directly in Pandas. For convenience, the matrix is rotated (transposed) so that each row represents one year and each column one day. This
+provides a more intuitive, left-to-right layout of the data.
+
+"""
+
+from pandas import read_csv
+from pandas import DataFrame
+from pandas import Grouper
+from matplotlib import pyplot
+series = read_csv('daily-min-temperatures.csv', header=0, index_col=0, parse_dates=True)
+series=series.squeeze()
+groups = series.groupby(Grouper(freq='A'))
+years = DataFrame()
+for name, group in groups:
+ years[name.year] = group.values
+years = years.T
+print(years)
+pyplot.matshow(years, interpolation=None, aspect='auto')
+pyplot.show()
+
+"""The plot shows the cooler minimum temperatures in the middle days of the years and
+the warmer minimum temperatures in the start and ends of the years, and all the fading and
+complexity in between.
+
+**Lag Scatter Plots**
+Time series modeling assumes a relationship between an observation and the previous observation.
+Previous observations in a time series are called lags, with the observation at the previous timestep called lag=1, the observation at two time steps ago lag=2, and so on. A useful type of plot
+to explore the relationship between each observation and a lag of that observation is called the
+scatter plot. Pandas has a built-in function for exactly this called the lag plot. It plots the
+observation at time t on the x-axis and the observation at the next time step (t+1) on the
+y-axis.
+
+If the points cluster along a diagonal line from the bottom-left to the top-right of the plot,
+it suggests a positive correlation relationship.
+ˆ If the points cluster along a diagonal line from the top-left to the bottom-right, it suggests
+a negative correlation relationship.
+ˆ Either relationship is good as they can be modeled.
+
+More points tighter in to the diagonal line suggests a stronger relationship and more spread
+from the line suggests a weaker relationship. A ball in the middle or a spread across the plot
+suggests a weak or no relationship.
+"""
+
+from pandas.plotting import lag_plot
+lag_plot(series)
+pyplot.show()
+
+"""The plot created from running the example shows a relatively strong positive correlation
+between observations and their lag1 values
+
+**Autocorrelation Plots**
+We can quantify the strength and type of relationship between observations and their lags. In
+statistics, this is called correlation, and when calculated against lag values in time series, it is
+called autocorrelation (self-correlation). A correlation value calculated between two groups of
+numbers, such as observations and their lag=1 values, results in a number between -1 and 1.
+The sign of this number indicates a negative or positive correlation respectively. A value close to
+zero suggests a weak correlation, whereas a value closer to -1 or 1 indicates a strong correlation.
+Correlation values, called correlation coefficients, can be calculated for each observation and
+different lag values. Once calculated, a plot can be created to help better understand how this
+relationship changes over the lag. This type of plot is called an autocorrelation plot and Pandas provides this capability built in, called the autocorrelation plot() function.
+"""
+
+from pandas.plotting import autocorrelation_plot
+autocorrelation_plot(series)
+pyplot.show()
+
+"""The resulting plot shows lag along the x-axis and the correlation on the y-axis. Dotted lines
+are provided that indicate any correlation values above those lines are statistically significant
+(meaningful). We can see that for the Minimum Daily Temperatures dataset we see cycles of
+strong negative and positive correlation. This captures the relationship of an observation with
+past observations in the same and opposite seasons or times of year. Sine waves like those seen
+in this example are a strong sign of seasonality in the dataset
+"""

myawesomepkg-0.1.4/myawesomepkg/TSAPY1/tsa_practical_no_2.py

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+"""TSA_Practical No 2.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1X2scZpqK4F_dqV8QohehZCIZswnttekq
+
+**Practical No 2**
+**Aim: Implementing timeseries components**
+1.   Seasonality
+2.   Trend
+3.   Pattern
+4.   Cyclic
+
+**random.normal(loc=0.0, scale=1.0, size=None)**
+
+Draw random samples from a normal (Gaussian) distribution.
+
+**Parameters:**
+loc: float or array_like of floats
+Mean (“centre”) of the distribution.
+
+scale: float or array_like of floats
+Standard deviation (spread or “width”) of the distribution. Must be non-negative.
+
+size: int or tuple of ints, optional
+Output shape.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Upward Trend
+t = np.arange(0, 10, 0.1)
+data = t + np.random.normal(0, 0.5, len(t))
+plt.plot(t, data, label='Upward Trend')
+
+# Downward Trend
+t = np.arange(0, 10, 0.1)
+data = -t + np.random.normal(0, 0.5, len(t))
+plt.plot(t, data, label='Downward Trend')
+
+# Horizontal Trend
+t = np.arange(0, 10, 0.1)
+data = np.zeros(len(t)) + np.random.normal(0, 0.5, len(t))
+plt.plot(t, data, label='Horizontal Trend')
+
+# Non-linear Trend
+t = np.arange(0, 10, 0.1)
+data = t**2 + np.random.normal(0, 0.5, len(t))
+plt.plot(t, data, label='Non-linear Trend')
+
+plt.legend()
+plt.show()
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+# generate sample data with different types of seasonality
+np.random.seed(1)
+time = np.arange(0, 366)
+
+# weekly seasonality
+weekly_seasonality = np.sin(2 * np.pi * time / 7)
+weekly_data = 5 + weekly_seasonality
+
+# monthly seasonality
+monthly_seasonality = np.sin(2 * np.pi * time / 30)
+monthly_data = 5  + monthly_seasonality
+
+# annual seasonality
+annual_seasonality = np.sin(2 * np.pi * time / 365)
+annual_data = 5 + annual_seasonality
+
+# plot the data
+plt.figure(figsize=(12, 8))
+plt.plot(time, weekly_data,label='Weekly Seasonality')
+plt.plot(time, monthly_data,label='Monthly Seasonality')
+plt.plot(time, annual_data,label='Annual Seasonality')
+plt.legend(loc='upper left')
+plt.show()
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Generate sample data with cyclic patterns
+np.random.seed(1)
+time = np.array([0, 30, 60, 90, 120,
+                 150, 180, 210, 240,
+                 270, 300, 330])
+data = 10 * np.sin(2 * np.pi * time / 50) + 20 * np.sin(2 * np.pi * time / 100)
+
+# Plot the data
+plt.figure(figsize=(12, 8))
+plt.plot(time, data, label='Cyclic Data')
+plt.legend(loc='upper left')
+plt.xlabel('Time (days)')
+plt.ylabel('Value')
+plt.title('Cyclic Time Series Data')
+plt.show()
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Generate sample time series data
+np.random.seed(1)
+time = np.arange(0, 100)
+#data = 5 * np.sin(2 * np.pi * time / 20) + 2 * time
+data=np.sin(2 * np.pi * time / 30)+time
+
+# Introduce irregularities by adding random noise
+irregularities = np.random.normal(0, 5, len(data))
+irregular_data = data + irregularities
+
+# Plot the original data and the data with irregularities
+plt.figure(figsize=(12, 8))
+plt.plot(time, data, label='Original Data')
+plt.plot(time, irregular_data,label='Data with Irregularities')
+plt.legend(loc='upper left')
+plt.show()

myawesomepkg-0.1.4/myawesomepkg.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: myawesomepkg
+Version: 0.1.4
+Summary: A simple greeting library
+Author: Your Name
+Author-email: your.email@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

myawesomepkg-0.1.4/myawesomepkg.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+setup.py
+myawesomepkg/__init__.py
+myawesomepkg/core.py
+myawesomepkg.egg-info/PKG-INFO
+myawesomepkg.egg-info/SOURCES.txt
+myawesomepkg.egg-info/dependency_links.txt
+myawesomepkg.egg-info/top_level.txt
+myawesomepkg/TSAPY1/Practical No 1.py
+myawesomepkg/TSAPY1/Practical No 2.py
+myawesomepkg/TSAPY1/Practical No 3.py
+myawesomepkg/TSAPY1/Practical No 4 A.py
+myawesomepkg/TSAPY1/Practical No 4 B.py
+myawesomepkg/TSAPY1/Practical No 5.py
+myawesomepkg/TSAPY1/Practical No 6.py
+myawesomepkg/TSAPY1/Practical No 7.py
+myawesomepkg/TSAPY1/Practical No 8.py
+myawesomepkg/TSAPY1/__init__.py
+myawesomepkg/TSAPY1/practical_no_3.py
+myawesomepkg/TSAPY1/practical_no_4.py
+myawesomepkg/TSAPY1/practical_no_4b.py
+myawesomepkg/TSAPY1/practical_no_5_ac_and_pca.py
+myawesomepkg/TSAPY1/practical_no_6.py
+myawesomepkg/TSAPY1/practical_no_7.py
+myawesomepkg/TSAPY1/practical_no_8.py
+myawesomepkg/TSAPY1/tsa_practical_no_1.py
+myawesomepkg/TSAPY1/tsa_practical_no_2.py

myawesomepkg-0.1.4/setup.py

@@ -0,0 +1,18 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='myawesomepkg',                   # Your package name
+    version='0.1.4',                       # Current version
+    author='Your Name',                    # Replace with your actual name
+    author_email='your.email@example.com', # Optional: add your email
+    description='A simple greeting library',
+    long_description_content_type='text/markdown',
+    packages=find_packages(),
+    install_requires=[],                   # List dependencies here, e.g., ['numpy']
+    python_requires='>=3.6',
+    classifiers=[                          # Optional but good for PyPI listings
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',  # Change to your license
+        'Operating System :: OS Independent',
+    ],
+)

myawesomepkg-0.1.3/PKG-INFO

@@ -1,6 +0,0 @@
-Metadata-Version: 2.1
-Name: myawesomepkg
-Version: 0.1.3
-Summary: A simple greeting library
-Author: Your Name
-Requires-Python: >=3.6

myawesomepkg-0.1.3/myawesomepkg/d.py

@@ -1,36 +0,0 @@
-import math
-n=int(input("Enter no of input neurons:"))
-
-print("enter input")
-inputs=[]
-
-for i in range(0,n):
-    x=float(input())
-    inputs.append(x)
-print(inputs)
-
-print("enter weight")
-weights=[]
-
-for i in range(0,n):
-    w=float(input())
-    weights.append(w)
-print(weights)
-
-print(" the net input is calculated as Yin=x1w1+x2w2+x3w3")
-
-Yin=[]
-for i in range(0,n):
-    Yin.append(inputs[i]*weights[i])
-ynet=round(sum(Yin),3)
-
-print("net input for y neuron",ynet)
-
-print("apply activation function over net input, Binary function")
-
-y=round(1/(1+math.exp(-ynet)),3)
-print(y)
-
-print("apply activation function over net input, Bipolar function")
-y=round((2/(1+math.exp(-ynet)))-1,3)
-print(y)

myawesomepkg-0.1.3/myawesomepkg.egg-info/PKG-INFO

@@ -1,6 +0,0 @@
-Metadata-Version: 2.1
-Name: myawesomepkg
-Version: 0.1.3
-Summary: A simple greeting library
-Author: Your Name
-Requires-Python: >=3.6

myawesomepkg-0.1.3/myawesomepkg.egg-info/SOURCES.txt

@@ -1,18 +0,0 @@
-setup.py
-myawesomepkg/__init__.py
-myawesomepkg/core.py
-myawesomepkg/d.py
-myawesomepkg.egg-info/PKG-INFO
-myawesomepkg.egg-info/SOURCES.txt
-myawesomepkg.egg-info/dependency_links.txt
-myawesomepkg.egg-info/top_level.txt
-myawesomepkg/TSAPY/Practical No 1.py
-myawesomepkg/TSAPY/Practical No 2.py
-myawesomepkg/TSAPY/Practical No 3.py
-myawesomepkg/TSAPY/Practical No 4 A.py
-myawesomepkg/TSAPY/Practical No 4 B.py
-myawesomepkg/TSAPY/Practical No 5.py
-myawesomepkg/TSAPY/Practical No 6.py
-myawesomepkg/TSAPY/Practical No 7.py
-myawesomepkg/TSAPY/Practical No 8.py
-myawesomepkg/TSAPY/__init__.py

myawesomepkg-0.1.3/setup.py

@@ -1,11 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name='myawesomepkg',               # Change this to your library name
-    version='0.1.3',
-    author='Your Name',                # Put your name here
-    description='A simple greeting library',
-    packages=find_packages(),
-    install_requires=[],               # Add required libraries here, if any
-    python_requires='>=3.6',
-)