import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
df = pd.read_csv('/content/drive/My Drive/Colab Notebooks/random.csv', parse_dates=['Date'],
index_col='Date')
#Correlation
import matplotlib.pyplot as plt
# Plot the time series
plt.figure(figsize=(14, 7))
plt.plot(df['CORN'], label='Corn Prices')
plt.plot(df['Raw Sugar'], label='Raw Sugar Prices')
plt.title('Corn vs. Raw Sugar Prices Over Time')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.show()
# Correlation analysis
correlation = df['CORN'].corr(df['Raw Sugar'])
print(f"Correlation between Corn and Raw Sugar prices: {correlation}")
#Test Stationarity
from statsmodels.tsa.stattools import adfuller
# Define a function to perform the ADF test
def adf_test(series):
result = adfuller(series)
print(f'ADF Statistic: {result[0]}')
print(f'p-value: {result[1]}')
for key, value in result[4].items():
print('Critial Values:')
print(f' {key}, {value}')
print("Corn Price Stationarity Test")
adf_test(df['CORN'])
print("\nRaw Sugar Price Stationarity Test")
adf_test(df['Raw Sugar'])
# Differencing if needed
df['Corn_diff'] = df['CORN'].diff().dropna()
df['Raw_Sugar_diff'] = df['Raw Sugar'].diff().dropna()
print("Corn Price Stationarity Test")
adf_test(df['Corn_diff'].dropna())
print("\nRaw Sugar Price Stationarity Test")
adf_test(df['Raw_Sugar_diff'].dropna())
#Caluculate ACF
from pmdarima import auto_arima
# Auto-ARIMA to find best parameters for Corn
corn_auto_model = auto_arima(df['Corn_diff'].dropna(), seasonal=False, trace=True)
# Auto-ARIMA to find best parameters for Raw Sugar
sugar_auto_model = auto_arima(df['Raw_Sugar_diff'].dropna(), seasonal=False, trace=True)
#Forecast
from statsmodels.tsa.arima.model import ARIMA
# Fit ARIMA model on differenced data if required
corn_model = ARIMA(df['Corn_diff'].dropna(), order=(0,0,0)) # adjust order based on ACF and PACF
corn_fit = corn_model.fit()
print(corn_fit.summary())
# Forecast Corn Prices
corn_forecast = corn_fit.forecast(steps=12)
print("Corn Price Forecast:", corn_forecast)
# Similar approach for Raw Sugar
sugar_model = ARIMA(df['Raw_Sugar_diff'].dropna(), order=(0,0,0))
sugar_fit = sugar_model.fit()
print(sugar_fit.summary())
# Forecast Raw Sugar Prices
sugar_forecast = sugar_fit.forecast(steps=100)
print("Raw Sugar Price Forecast:", sugar_forecast)
# Assuming df.index is of type string, convert it to datetime
df.index = pd.to_datetime(df.index, format="%d-%m-%Y")
# Create a date range for the forecasted values
forecast_dates = pd.date_range(df.index[-1] + pd.Timedelta(days=1), periods=100, freq='D')
# Plotting
plt.figure(figsize=(14, 7))
# Plot original data
#plt.plot(df['Corn_diff'].iloc[-500:], label='Corn Prices', color='blue')
plt.plot(df['Raw_Sugar_diff'].iloc[-500:], label='Raw Sugar Prices', color='green')
# Plot forecasted data
#plt.plot(forecast_dates, corn_forecast, label='Corn Forecast', color='blue', linestyle='--')
plt.plot(forecast_dates, sugar_forecast, label='Raw Sugar Forecast', color='green', linestyle='--')
plt.title('Corn and Raw Sugar Prices with Forecast')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.show()
# VAR Modelling
from statsmodels.tsa.api import VAR
# Fit a VAR model
model = VAR(df[['CORN', 'Raw Sugar']])
model_fitted = model.fit(maxlags=None, ic='aic')
# Display the model summary
print(model_fitted.summary())
print(len(model_fitted.coefs))
#if len(model_fitted.coefs) > 0:
# Forecast the next 10 periods
forecast_steps = 100
forecast = model_fitted.forecast(df[['CORN', 'Raw Sugar']].values[-model_fitted.k_ar:],
steps=forecast_steps)
# Convert forecast to a DataFrame
forecast_index = pd.date_range(start=df.index[-1] + pd.Timedelta(days=1), periods=forecast_steps,
freq='D')
forecast_df = pd.DataFrame(forecast, index=forecast_index, columns=['CORN', 'Raw Sugar'])
print(forecast_df)
# Plot the forecasted values
plt.figure(figsize=(12, 6))
plt.plot(df.index, df['Raw Sugar'], label='Historical Sugar Price', color='blue')
plt.plot(forecast_df.index, forecast_df['Raw Sugar'], label='Forecasted Sugar Price', color='red')
plt.title('Sugar Price Forecast Using VAR Model')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.show()
#train model
# Split data into training and testing sets (80/20 split)
train_size = int(len(df) * 0.8)
train, test = df[:train_size], df[train_size:]
# Fit the model on the training data
model_fitted_train = model.fit(maxlags=None, ic='aic')
# Predict on the test data
test_forecast = model_fitted_train.forecast(train[['CORN', 'Raw Sugar', 'USDBRL']].values[-
model_fitted_train.k_ar:], steps=len(test))
# Compare actual vs predicted
test_forecast_df = pd.DataFrame(test_forecast, index=test.index, columns=['CORN', 'Raw Sugar',
'USDBRL'])
plt.figure(figsize=(12, 6))
plt.plot(test.index, test['Raw Sugar'], label='Actual Sugar Price', color='blue')
plt.plot(test_forecast_df.index, test_forecast_df['Raw Sugar'], label='Predicted Sugar Price',
color='red')
plt.title('Actual vs Predicted Sugar Prices')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.show()
#test model
from sklearn.metrics import mean_squared_error
# Calculate RMSE for the model's performance on test data
rmse = mean_squared_error(test['Raw Sugar'], test_forecast_df['Raw Sugar'], squared=False)
print(f'Root Mean Squared Error (RMSE): {rmse}')
import numpy as np
# Define the function to calculate MAPE
def mean_absolute_percentage_error(y_true, y_pred):
# Convert to numpy arrays (in case they are lists or pandas series)
y_true = np.array(y_true)
y_pred = np.array(y_pred)
# Avoid division by zero by replacing zeros with a small value
epsilon = 1e-10
y_true = np.where(y_true == 0, epsilon, y_true)
# Calculate MAPE
mape = np.mean(np.abs((y_true - y_pred) / y_true)) * 100
return mape
mape = mean_absolute_percentage_error(test['Raw Sugar'], test_forecast_df['Raw Sugar'])
print(mape)
