import numpy as npimport pandas as pdimport seaborn as snsimport matplotlib.pyplot as pltimport warningswarnings.filterwarnings('ignore')

data = pd.read_csv('INDIAVIX.csv')

data.head()

data.tail()

data.columns

data.dtypes

data.info()

data.describe()

data.Change.value_counts()

data.corr()

# Checking mean median and modeprint(data.mean())print(data.median())print(data.mode())

 # Converting 'Date' is the column containing date objects
# Convert 'Date' column to datetime with the correct formatdata["Date"] = pd.to_datetime(data["Date"], format='%d-%m-%Y')
# Extract day, month, and year into separate columnsdata['Day'] = data['Date'].dt.daydata['Month'] = data['Date'].dt.monthdata['Year'] = data['Date'].dt.year

data = data.dropna(subset=['Previous'])

data.isnull().sum()

data.dtypes

#Line Plotplt.figure(figsize=(10, 6))plt.plot(data['Date'], data['Close'])plt.title('Stock Price Over Time')plt.xlabel('Date')plt.ylabel('Price')plt.show()

plt.figure(figsize=(10, 6))plt.plot(data['Date'], data['Close'].pct_change().rolling(window=20).std(), label='Volatility')plt.title('Volatility Plot')plt.xlabel('Date')plt.ylabel('Volatility')plt.legend()plt.show()

# The heatMap plotcorr_matrix = data.corr()plt.figure(figsize=(10, 8))sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', fmt=".2f")plt.title('Correlation Heatmap')plt.show()

sns.displot(x=data['Change'])

from autoviz.AutoViz_Class import AutoViz_ClassAV=AutoViz_Class()data=AV.AutoViz(filename="INDIAVIX.csv",verbose=2,chart_format='html')

sns.pairplot(data)

data.corr()

# Here I'm creating seprate colomns for MA_5 and STD_5 who's based on close of mean and standered daviationdata['MA_5'] = data['Close'].rolling(window=5).mean()data['STD_5'] = data['Close'].rolling(window=5).std()

## Plotting the autocorrelation functionfrom statsmodels.graphics.tsaplots import plot_acf# Set up the figure and axes using seaborn styleplt.figure(figsize=(12, 6))sns.set(style='whitegrid')# Plot the ACF using plot_acf from statsmodelsplot_acf(data['Close'], lags=20, alpha=0.05, ax=plt.gca()) plt.title('Autocorrelation Function (ACF) of Close Prices')plt.xlabel('Lag')plt.ylabel('Autocorrelation') plt.show()

from statsmodels.tsa.stattools import adfuller
# Assuming 'data' is your DataFrame with stock data, and 'Close' is the column of interestdftest = adfuller(data['Close'], autolag='AIC')
# Extract and print resultsprint("Results of Augmented Dickey-Fuller Test:")print("ADF Statistic: %f" % dftest[0])print("P-value: %f" % dftest[1])print("Number of Lags Used: %d" % dftest[2])print("Number of Observations Used: %d" % dftest[3])print("Critical Values:")for key, val in dftest[4].items():    print("\t%s: %.3f" % (key, val))
# Interpret the resultsif dftest[1] <= 0.05:    print("Conclusion: Reject the null hypothesis.")    print("The data is stationary.")else:    print("Conclusion: Fail to reject the null hypothesis.")    print("The data is non-stationary.")

data1=data.diff(periods=1)data1=data1.iloc[1:] #null value discardedata1

## Plotting the autocorrelation function # Set up the figure and axes using seaborn styleplt.figure(figsize=(12, 6))sns.set(style='whitegrid')# Plot the ACF using plot_acf from statsmodelsplot_acf(data1['Close'], lags=20, alpha=0.05, ax=plt.gca()) plt.title('Autocorrelation Function (ACF) of Close Prices')plt.xlabel('Lag')plt.ylabel('Autocorrelation') plt.show()

 data2=data1.diff(periods=1) # differencing applied to data1 data2=data2.iloc[1:] # integrated to the order of 2  ## Plotting the autocorrelation function # Set up the figure and axes using seaborn styleplt.figure(figsize=(12, 6))sns.set(style='whitegrid')# Plot the ACF using plot_acf from statsmodelsplot_acf(data1['Close'], lags=20, alpha=0.05, ax=plt.gca()) plt.title('Autocorrelation Function (ACF) of Close Prices')plt.xlabel('Lag')plt.ylabel('Autocorrelation') plt.show()

# Select the Close price columnclose_data = data['Close']
# Split the data into training and testing setstrain_size = int(len(data) * 0.8)train, test = close_data[:train_size], close_data[train_size:]

train.info()#info about datatype and null value

## Applying autoregressive model#from statsmodels.tsa.ar_model import AR##from statsmodels.tsa.ar_model import AutoRegfrom statsmodels.tsa.ar_model import ar_select_order, AutoRegimport warningswarnings.filterwarnings('ignore')

# Use ar_select_order to find the best lagsmod = ar_select_order(close_data, maxlag=15, glob=True)best_lags = mod.ar_lagsprint("Best lags:", best_lags)

# fitting Modelar_model = AutoReg(train, lags=best_lags)ar_model_fit = ar_model.fit()# Summary of the modelprint(ar_model_fit.summary())

# Forecaststart = len(train)end = len(train) + len(test) - 1ar_predictions = ar_model_fit.predict(start=start, end=end, dynamic=False)# Ensure no NaN values in predictionsar_predictions = ar_predictions.dropna()test = test[:len(ar_predictions)]

# Evaluate the modelfrom sklearn.metrics import mean_squared_errorrmse = mean_squared_error(test, ar_predictions, squared=False)print(f'RMSE: {rmse}')# Plotplt.figure(figsize=(10, 5))plt.plot(train.index, train, label='Train')plt.plot(test.index, test, label='Test')plt.plot(ar_predictions.index, ar_predictions, label='Predictions')plt.legend()plt.show()

# Plotplt.plot(test)plt.plot(ar_predictions,color='green') #graph of test vs prediction

## importing the libraryfrom statsmodels.tsa.arima.model import ARIMA

# Determine the optimal order for ARIMA model (using the best AR lags for p, and setting d=1 and q=0)p = len(best_lags)d = 1q = 0# Split the data into training and testing setstrain_size = int(len(close_data) * 0.8)train, test = close_data[:train_size], close_data[train_size:]# Fit the ARIMA modelarima_model= ARIMA(train, order=(p, d, q))arima_model_fit = arima_model.fit()# Summary of the modelprint(arima_model_fit.summary())

# Forecaststart = len(train)end = len(train) + len(test) - 1arima_predictions = arima_model_fit.predict(start=start, end=end, dynamic=False)# Ensure no NaN values in predictionsarima_predictions = arima_predictions.dropna()test = test[:len(arima_predictions)]

# Evaluate the modelfrom sklearn.metrics import mean_squared_errorrmse = mean_squared_error(test, arima_predictions, squared=False)print(f'RMSE: {rmse}')# Plotplt.figure(figsize=(10, 5))plt.plot(train.index, train, label='Train')plt.plot(test.index, test, label='Test')plt.plot(arima_predictions.index, arima_predictions, label='Predictions')plt.legend()plt.show()

 # Ensure no NaN values in predictionsar_predictions = ar_predictions.dropna()test_ar = test[:len(ar_predictions)]

# Comparision of actual vs predicted for 9 valuesplt.plot(test[:9])plt.plot(arima_predictions,color='green')#line plot for prediction

# Comparision of actual vs predicted for 25 valuesplt.plot(test[:25])plt.plot(arima_predictions,color='green') #line plot for prediction

import numpy as npfrom sklearn.metrics import mean_squared_errorfrom statsmodels.tools.eval_measures import rmse
# Define the accuracy metrics functiondef forecast_accuracy(forecast, actual):    mse = np.mean((forecast - actual)**2)        # Mean Squared Error (MSE)    mae = np.mean(np.abs(forecast - actual))     # Mean Absolute Error (MAE)    rmse = np.mean((forecast - actual)**2)**.5   # Root Mean Squared Error (RMSE)        return {'mse': mse, 'mae': mae, 'rmse': rmse}
# Assuming forecast25 and test1 are your forecasted and actual values respectivelyforecast25 = arima_predictionstest1 = test

# Calculate and print accuracy metricsaccuracy_metrics = forecast_accuracy(forecast25, test1)print("Accuracy metrics:", accuracy_metrics)# Calculate and print RMSE using statsmodelsprint("RMSE (statsmodels):", rmse(test1, forecast25))# Calculate and print MSE using sklearnprint("MSE (sklearn):", mean_squared_error(test1, forecast25))

from sklearn.metrics import mean_squared_errorfrom statsmodels.tools.eval_measures import rmse# Calculate root mean squared errorprint(rmse(test1, forecast25))# Calculate mean squared errormean_squared_error(test1, forecast25)

# Ensure no NaN values in predictionsarima_predictions = arima_predictions.dropna()test_arima = test[:len(arima_predictions)]

# Calculate accuracy metrics for AR modelar_accuracy = forecast_accuracy(ar_predictions, test_ar)print("The AR model accuracy metrics:", ar_accuracy)# Calculate accuracy metrics for ARIMA modelarima_accuracy = forecast_accuracy(arima_predictions, test_arima)print("The ARIMA model accuracy metrics:", arima_accuracy)# Additional metrics using sklearn and statsmodelsprint("The AR model RMSE (statsmodels):", rmse(test_ar, ar_predictions))print("The AR model MSE (sklearn):", mean_squared_error(test_ar, ar_predictions))print("The ARIMA model RMSE (statsmodels):", rmse(test_arima, arima_predictions))print("The ARIMA model MSE (sklearn):", mean_squared_error(test_arima, arima_predictions))

plt.figure(figsize=(12, 6))
# Plot the actual valuesplt.plot(train.index, train, label='Train')plt.plot(test.index, test, label='Test', color='gray')
# Plot the AR model forecastsplt.plot(test_ar.index, ar_predictions, label='AR Predictions', color='blue')
# Plot the ARIMA model forecastsplt.plot(test_arima.index, arima_predictions, label='ARIMA Predictions', color='red')
plt.xlabel('Date')plt.ylabel('Close Price')plt.title('Actual vs Forecasted Close Prices')plt.legend()plt.show()