Code Word File

Amazon ARMA model
Loading and Visualizing Data

# Loads the Amazon stock data and set its frequency
import pandas as pd
df = pd.read_csv("AMZN.csv", parse_dates=['Date'], index_col='Date')
df = df.asfreq('D').fillna(method='ffill')
closing_prices = df['Close']
# Visualizing the closing prices over time using matplotlib.
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 6))
plt.plot(closing_prices, label='Closing Prices')
plt.title('Amazon Stock Closing Prices Over Time')
plt.xlabel('Date')
plt.ylabel('Closing Price')
plt.legend()
plt.show()
Splitting Data
train_size = int(len(closing_prices) * 0.8)
train, test = closing_prices[:train_size], closing_prices[train_size:]
Time Series Analysis

# Plot ACF and PACF of the original time series to see if the data is stationary
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
acf_original = plot_acf(train)
pacf_original = plot_pacf(train)
# Perform Augmented Dickey-Fuller test for stationarity
from statsmodels.tsa.stattools import adfuller
adf_test = adfuller(train)
print(f'p-value: {adf_test[1]}')
p-value: 0.6863921026685542
Making Data stationary

# Differencing to make the series stationary
train_diff = train.diff().dropna()
# Visualizing the differenced data
plt.plot(train_diff, label='1st Order Differenced Closing Prices')
plt.title('1st Order Differenced Amazon Stock Closing Prices')
plt.xlabel('Date')
plt.ylabel('Differenced Closing Price')
plt.legend()
plt.show()
# Again using ACF and Pacf to check its stationarity
acf_diff = plot_acf(train_diff)
pacf_diff = plot_pacf(train_diff)
# Perform Augmented Dickey-Fuller test for stationarity
adf_test_diff = adfuller(train_diff)
print(f'p-value: {adf_test_diff[1]}')
p-value: 0.0
Auto ARMA Model

from pmdarima import auto_arima
# Use auto_arima to find the best model
model = auto_arima(train_diff, suppress_warnings=True, seasonal=False)
# Get the best order
best_order = model.get_params()['order']
print("Best Order:", best_order)
Best Order: (2, 0, 2)

ARMA Model Fitting
import itertools
from statsmodels.tsa.arima.model import ARIMA
# Fit ARMA model with the best order
p, q = 2, 2
model = ARIMA(train_diff, order=(p, 0, q))
results = model.fit()
# Check AIC and BIC values
aic = results.aic
bic = results.bic
print(f'AIC: {aic}')
print(f'BIC: {bic}')
AIC: 6244.2862338379855
BIC: 6275.995159313397
# Check the residuals for randomness and stationarity
residuals = results.resid
plt.plot(residuals)
plt.title('Residuals of ARMA Model')
plt.xlabel('Date')
plt.ylabel('Residuals')
plt.show()
Forecasting and Evaluation
# Forecast on the test values
forecast_steps = len(test)
forecast = results.forecast(steps=forecast_steps)
# Plot actual vs predicted values for the test set
plt.plot(test.index, test.values, label='Actual')
plt.plot(test.index, forecast, label='Predicted')

plt.title('ARIMA Model - Actual vs Predicted on Test Set')
plt.xlabel('Date')
plt.ylabel('Closing Price')
plt.legend()
plt.show()
MSE and MAE
# Calculate Mean Squared Error (MSE) and Mean Absolute Error (MAE)
from sklearn.metrics import mean_squared_error, mean_absolute_error
mse = mean_squared_error(test, forecast)
mae = mean_absolute_error(test, forecast)
print(f'Mean Squared Error (MSE): {mse}')

print(f'Mean Absolute Error (MAE): {mae}')
Mean Squared Error (MSE): 14503.066111204844
Mean Absolute Error (MAE): 118.31058324851284
Forecasting the closing value

# Predict the closing value of the next day
last_observation = closing_prices.index[-1]
next_day = last_observation + pd.Timedelta(days=1)
predicted_next_day = results.forecast(steps=1)[0]
print(f'Predicted Closing Value for {next_day.date()}: {predicted_next_day}')
Predicted Closing Value for 2023-02-18: 0.3408541885702173
PSD
import numpy as np
from scipy.fft import fft
closing_prices = df['Close'].values # Convert pandas Series to NumPy array
# Compute the FFT
fft_values = fft(closing_prices)
# Compute the Power Spectral Density (PSD)
psd_values = np.abs(fft_values) ** 2
# Plot the PSD
plt.plot(psd_values)
plt.title('Power Spectral Density (PSD)')
plt.xlabel('Frequency')
plt.ylabel('Power')
plt.show()
# it suggests that the data may not exhibit strong periodic behavior or
significant frequency components.
Spectrogram
from scipy.signal import spectrogram
closing_prices = df['Close']
# Compute the spectrogram
frequencies, times, spectrogram_values = spectrogram(closing_prices)
print("times shape:", times.shape)

print("frequencies shape:", frequencies.shape)
print("spectrogram_values.T shape:", spectrogram_values.T.shape)

times shape: (8,)
frequencies shape: (129,)
spectrogram_values.T shape: (8, 129)
# Plot the spectrogram
plt.pcolormesh(times, frequencies, np.log(spectrogram_values + 1e-10),

shading='auto')
plt.title('Spectrogram')
plt.xlabel('Time')
plt.ylabel('Frequency')
plt.colorbar(label='Log Power')
plt.show()
AMAZON neural network
Import Libraries and Load Data

import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler

from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM
from sklearn.metrics import mean_squared_error
import warnings
warnings.filterwarnings("ignore", category=FutureWarning)
Load and Preprocess Data

# Load the data
data = pd.read_csv('AMZN.csv')
closing_prices = data['Close'].values.reshape(-1, 1)
# Normalize the data
scaler = MinMaxScaler(feature_range=(0, 1))
closing_prices_normalized = scaler.fit_transform(closing_prices)
# Create a function to prepare the data for the LSTM model
def create_dataset(dataset, look_back=1):
dataX, dataY = [], []
for i in range(len(dataset) - look_back):

a = dataset[i:(i + look_back), 0]
dataX.append(a)
dataY.append(dataset[i + look_back, 0])
return np.array(dataX), np.array(dataY)
Create LSTM Dataset

# Define the look-back period
look_back = 10
# Prepare the dataset

X, Y = create_dataset(closing_prices_normalized, look_back)
Split Data into Training and Testing Sets

# Split the data into training and testing sets
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)
Reshape Data for LSTM Model

# Reshape input to be [samples, time steps, features] for LSTM model
X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))
X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))
Build and Train the LSTM Model

# Build the LSTM model
model = Sequential()
model.add(LSTM(units=50, input_shape=(look_back, 1)))
model.add(Dense(units=1))
model.compile(optimizer='adam', loss='mean_squared_error')
# Train the model
model.fit(X_train, Y_train, epochs=50, batch_size=32, verbose=2)

Epoch 1/50
32/32 - 3s - loss: 0.0684 - 3s/epoch - 88ms/step
Epoch 2/50
32/32 - 0s - loss: 0.0053 - 268ms/epoch - 8ms/step
Epoch 3/50
Epoch 4/50
Epoch 5/50
Epoch 6/50
Epoch 7/50
Epoch 8/50
Epoch 9/50
Epoch 10/50
Epoch 11/50
Epoch 12/50
Epoch 13/50
Epoch 14/50
Epoch 15/50
Epoch 16/50
Epoch 17/50
Epoch 18/50
Epoch 19/50
Epoch 20/50
Epoch 21/50
Epoch 22/50
Epoch 23/50
Epoch 24/50
Epoch 25/50
Epoch 26/50
Epoch 27/50
Epoch 28/50
Epoch 29/50
Epoch 30/50
Epoch 31/50
Epoch 32/50
Epoch 33/50
Epoch 34/50
Epoch 35/50
Epoch 36/50
Epoch 37/50
Epoch 38/50
Epoch 39/50
Epoch 40/50
Epoch 41/50
Epoch 42/50
Epoch 43/50
Epoch 44/50
Epoch 45/50
Epoch 46/50
Epoch 47/50
Epoch 48/50
Epoch 49/50
32/32 - 0s - loss: 9.9199e-04 - 257ms/epoch - 8ms/step
Epoch 50/50
Out[37]:
<keras.src.callbacks.History at 0x16408a60110>
Evaluate Model Performance on Test Data

# Make predictions on the test data
predictions = model.predict(X_test)
8/8 [==============================] - 1s 4ms/step
# Inverse transform the predictions and actual values to the original scale
predictions = scaler.inverse_transform(predictions)
Y_test_original = scaler.inverse_transform(Y_test.reshape(-1, 1))
# Calculate the root mean squared error (RMSE)
rmse = np.sqrt(mean_squared_error(Y_test_original, predictions))
print('Root Mean Squared Error:', rmse)
Root Mean Squared Error: 3.300441897865308
Visualize Predictions
# Plot the predictions against actual values
plt.plot(Y_test_original, label='Actual')
plt.plot(predictions, label='Predicted')
plt.legend()
plt.show()
Predict Next Day's Closing Value
# Prepare the last 'look_back' days of data
last_data = closing_prices[-look_back:]
last_data_normalized = scaler.transform(last_data.reshape(-1, 1))
# Reshape and predict
last_data_reshaped = last_data_normalized.reshape(1, look_back, 1)
next_day_prediction_normalized = model.predict(last_data_reshaped)
1/1 [==============================] - 0s 31ms/step
# Inverse transform to get the predicted closing value
next_day_prediction = scaler.inverse_transform(next_day_prediction_normalized)
print('Predicted Next Day Closing Value:', next_day_prediction[0, 0])

Predicted Next Day Closing Value: 98.60197
J&J ARMA model
import pandas as pd
import numpy as np
from statsmodels.tsa.stattools import adfuller, kpss
from statsmodels.tsa.seasonal import seasonal_decompose
from statsmodels.graphics.tsaplots import plot_acf,

plot_pacf
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error,

mean_squared_error
Loading and Visualizing Data
# Step 1: Load the CSV file
df = pd.read_csv('jj.csv', parse_dates=['date'],
index_col='date')
# Step 2: Decompose the time series to understand trends,

patterns, and seasonality
result = seasonal_decompose(df['data'], model='additive',

period=4)
result.plot()
plt.show()
Check for Stationarity

# Step 3: Check for stationarity
def check_stationarity(timeseries):
adf_result = adfuller(timeseries, autolag='AIC')

kpss_result = kpss(timeseries)
print('ADF Statistic:', adf_result[0])
print('p-value (ADF):', adf_result[1])
print('Critical Values (ADF):', adf_result[4])
print('\nKPSS Statistic:', kpss_result[0])
print('p-value (KPSS):', kpss_result[1])
print('Critical Values (KPSS):', kpss_result[3])
check_stationarity(df['data'])
ADF Statistic: 2.7420165734574735
p-value (ADF): 1.0
Critical Values (ADF): {'1%': -3.524624466842421, '5%': -2.9026070739026064,
'10%': -2.5886785262345677}
KPSS Statistic: 1.3634938602266964

p-value (KPSS): 0.01
Critical Values (KPSS): {'10%': 0.347, '5%': 0.463, '2.5%': 0.574, '1%': 0.739}
C:\Users\PMLS\AppData\Local\Temp\ipykernel_2036\3808783141.py:4:
InterpolationWarning: The test statistic is outside of the range of p-values
available in the
look-up table. The actual p-value is smaller than the p-value returned.
# apply differencing
df['data_diff'] = df['data'] - df['data'].shift(1)
check_stationarity(df['data_diff'].dropna())
ADF Statistic: -0.40740976363804116
p-value (ADF): 0.9088542416911313
'10%': -2.5886785262345677}
KPSS Statistic: 0.22139627096747283

p-value (KPSS): 0.1
available in the
look-up table. The actual p-value is greater than the p-value returned.
# Drop rows with missing values
df = df.dropna()
Log differencing
# Apply log differencing
df['data_log_diff'] = np.log(df['data']) - np.log(df['data'].shift(1))
# Check stationarity of log-differenced data
check_stationarity(df['data_log_diff'].dropna())
df = df.dropna()
ADF Statistic: -4.210044890698209
p-value (ADF): 0.0006335725359760862
'10%': -2.5874984279778395}
KPSS Statistic: 0.20166745754525875

p-value (KPSS): 0.1
available in the
look-up table. The actual p-value is greater than the p-value returned.
ACF and PACF Plots

# Step 4: ACF and PACF analysis for log-differenced data
plot_acf(df['data_log_diff'].dropna(), lags=20)
plt.show()
plot_pacf(df['data_log_diff'].dropna(), lags=20)
plt.show()
Splitting Data
# Step 5: Split data into training and test sets
train_size = int(len(df) * 0.7)
train, test = df['data_log_diff'][:train_size], df['data_log_diff'][train_size:]
Auto Arima
from pmdarima import auto_arima
# Use auto-arima to find the best model
autoarima_model = auto_arima(train, seasonal=True, suppress_warnings=True)
print(autoarima_model.summary())
SARIMAX Results
==============================================================================
Dep. Variable: y No. Observations: 57
Model: SARIMAX(3, 0, 2) Log Likelihood 54.168
Date: Sat, 16 Mar 2024 AIC -94.335
Time: 11:24:33 BIC -80.034
Sample: 0 HQIC -88.777
- 57
Covariance Type: opg
==============================================================================
coef std err z P>|z| [0.025 0.975]
------------------------------------------------------------------------------
intercept 0.1618 0.025 6.490 0.000 0.113 0.211
ar.L1 -0.9634 0.088 -10.895 0.000 -1.137 -0.790
ar.L2 -0.9728 0.066 -14.730 0.000 -1.102 -0.843
ar.L3 -0.9187 0.036 -25.298 0.000 -0.990 -0.848
ma.L1 0.2672 0.166 1.612 0.107 -0.058 0.592
ma.L2 0.3396 0.154 2.202 0.028 0.037 0.642
sigma2 0.0079 0.002 4.197 0.000 0.004 0.012
=================================================================================
==
Ljung-Box (L1) (Q): 0.01 Jarque-Bera (JB):
0.06
Prob(Q): 0.93 Prob(JB):
0.97
Heteroskedasticity (H): 1.09 Skew:
0.08
Prob(H) (two-sided): 0.85 Kurtosis:
3.02
=================================================================================
==
Warnings:
[1] Covariance matrix calculated using the outer product of gradients (complex-
step).
Model Fitting to ARMA Model

print(autoarima_model.order)
(3, 0, 2)
# 6. Model Fitting
arima_model = ARIMA(train, order=autoarima_model.order)
arima_fit = arima_model.fit()
# 7. Check residuals
residuals = arima_fit.resid
plt.plot(residuals)
plt.show()
Forecast Accuracy
# 8. Evaluate forecast accuracy
arima_forecast = arima_fit.forecast(steps=len(test))
mae = mean_absolute_error(test, arima_forecast)
mse = mean_squared_error(test, arima_forecast)
rmse = np.sqrt(mse)
print(f'MAE: {mae:.2f}')
print(f'MSE: {mse:.2f}')
print(f'RMSE: {rmse:.2f}')
MAE: 0.14
MSE: 0.03
RMSE: 0.18
# 9. Plotting predictions on test data
plt.plot(df.index[train_size:], df['data_log_diff'][train_size:], label='Actual

Log-Differenced')
plt.plot(df.index[train_size:], arima_forecast, label='ARIMA Forecast')
plt.legend()
plt.title('ARIMA Model Forecast on Test Data')
plt.show()
# 10. Forecast next 24 months
forecast_steps = 24
forecast_index = pd.date_range(df.index[-1], periods=forecast_steps + 1, freq='M')[1:]
arima_next_24_forecast = arima_fit.forecast(steps=forecast_steps)
# 11. Plotting forecasted values on log differenced data
plt.plot(df.index, df['data_log_diff'], label='Actual Log-Differenced')
plt.plot(forecast_index, arima_next_24_forecast, label='ARIMA Forecast Next 24 Months')
plt.legend()
plt.title('ARIMA Model Forecast for Next 24 Months')
plt.show()
# 10. Forecast next 24 months on actual data
n_forecast = 24
predict = arima_fit.get_prediction(end=arima_model.nobs +
n_forecast)
idx = np.arange(len(predict.predicted_mean))
fig, ax = plt.subplots()
ax.plot(df['data'], 'blue')
ax.plot(idx[-n_forecast:], predict.predicted_mean[-
n_forecast:], 'k--')
ax.set(title='Forecast of Johnson&Johnson Sales')
plt.show()
predictions_int = arima_fit.get_forecast(steps=24)
predictions_int.predicted_mean
57 -0.117143
58 0.126009
59 0.079427
60 0.070450
61 -0.099362
62 0.115915
63 0.081700
64 0.061709
65 -0.083857
66 0.107373
67 0.082908
68 0.054579
69 -0.070298
70 0.100121
71 0.083281
72 0.048791
73 -0.058409
74 0.093943
75 0.083007
76 0.044120
77 -0.047955
78 0.088657
79 0.082240
80 0.040376
Name: predicted_mean, dtype: float64
Power Spectral Density

import numpy as np
from scipy.fft import fft
# Compute the FFT
fft_values = fft(df)
# Compute the Power Spectral Density (PSD)
psd_values = np.abs(fft_values) ** 2
# Plot the periodogram
plt.plot(psd_values)
plt.title('Power Spectral Density (Periodogram)')
plt.ylabel('Power')
plt.show()
# Plot only the first half of the PSD (due to symmetry)
plt.plot(psd_values[:len(df) // 2])
plt.title('Power Spectral Density (Periodogram)')
plt.ylabel('Power')
plt.show()
Spectrogram
from scipy.signal import spectrogram
# Compute the spectrogram
frequencies, times, spectrogram_values = spectrogram(df)
print("times shape:", times.shape)
print("frequencies shape:", frequencies.shape)
print("spectrogram_values.T shape:", spectrogram_values.T.shape)

times shape: (1,)
frequencies shape: (2,)
spectrogram_values.T shape: (1, 2, 82)
# Reshape the spectrogram_values to match the dimensions expected by pcolormesh
spectrogram_values_reshaped = spectrogram_values.T.squeeze()
times = np.arange(len(df))
# Plot the spectrogram
plt.pcolormesh(times, frequencies, np.log(spectrogram_values_reshaped + 1e-10),

shading='auto')
plt.title('Spectrogram')
plt.xlabel('Time')
plt.ylabel('Frequency')
plt.colorbar(label='Log Power')
plt.show()
jj neural network
Importing Libraries:
import pandas as pd
import numpy as np
import tensorflow as tf
from sklearn.preprocessing import
MinMaxScaler
from sklearn.metrics import
mean_squared_error
from tensorflow.keras.models import
Sequential
from tensorflow.keras.layers import Dense,
LSTM
Load and Preprocess Data:

# Load the data from the CSV file
data = pd.read_csv('jj.csv')
sales_data =
data['data'].values.astype(float).reshape(-1, 1)
# Normalize the data using Min-Max scaling
scaler = MinMaxScaler(feature_range=(0, 1))
sales_data_normalized =
scaler.fit_transform(sales_data)
# Function to create sequences for time series
forecasting
def create_sequences(data, seq_length):
sequences = []
for i in range(len(data) - seq_length):
seq = data[i:i + seq_length]
sequences.append(seq)
return np.array(sequences)
# Set the sequence length
sequence_length = 12
# Create sequences for training
training_sequences =
create_sequences(sales_data_normalized,
sequence_length)
Split Data for Training and Testing:

# Split data into training and testing sets
training_size = int(len(training_sequences) * 0.8)
training_data = training_sequences[:training_size]
testing_data = training_sequences[training_size:]
# Split the data into input (X) and output (y)

X_train, y_train = training_data[:, :-1], training_data[:,
-1]
X_test, y_test = testing_data[:, :-1], testing_data[:, -1]
Prepare Input and Output Data:

# Reshape input to be 3D [samples, timesteps,
features]
X_train = X_train.reshape((X_train.shape[0],
X_train.shape[1], 1))
X_test = X_test.reshape((X_test.shape[0],
X_test.shape[1], 1))
Build the LSTM Model:

# Build the LSTM model
model = Sequential()
model.add(LSTM(50, input_shape=(X_train.shape[1],
1)))
model.add(Dense(1))
model.compile(optimizer='adam',
loss='mean_squared_error')
Train the Model:

# Train the model
model_fit= model.fit(X_train, y_train, epochs=50,

batch_size=32, verbose=2)
Epoch 1/50
Epoch 2/50
Epoch 3/50
Epoch 4/50
Epoch 5/50
Epoch 6/50
Epoch 7/50
Epoch 8/50
Epoch 9/50
Epoch 10/50
Epoch 11/50
Epoch 12/50
Epoch 13/50
Epoch 14/50
Epoch 15/50
Epoch 16/50
Epoch 17/50
Epoch 18/50
Epoch 19/50
Epoch 20/50
Epoch 21/50
Epoch 22/50
Epoch 23/50
Epoch 24/50
Epoch 25/50
Epoch 26/50
Epoch 27/50
Epoch 28/50
Epoch 29/50
Epoch 30/50
Epoch 31/50
Epoch 32/50
Epoch 33/50
Epoch 34/50
Epoch 35/50
Epoch 36/50
Epoch 37/50
Epoch 38/50
Epoch 39/50
Epoch 40/50
Epoch 41/50
Epoch 42/50
Epoch 43/50
Epoch 44/50
Epoch 45/50
Epoch 46/50
Epoch 47/50
Epoch 48/50
Epoch 49/50
Epoch 50/50
Test the Model:

# Test the model
test_loss = model.evaluate(X_test, y_test, verbose=0)
print(f'Test Loss: {test_loss}'
Test Loss: 0.01699160970747471
Make Future Predictions

# Make predictions for the next 24 months
future_predictions = []
current_sequence = list(X_test[-1].flatten())
for i in range(24):
input_sequence = np.array(current_sequence[-(sequence_length-1):]).reshape(1,
sequence_length-1, 1)
predicted_value = model.predict(input_sequence)[0][0]
future_predictions.append(predicted_value)
current_sequence.append(predicted_value)
1/1 [==============================] - 0s 23ms/step

1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 29ms/step
1/1 [==============================] - 0s 33ms/step
1/1 [==============================] - 0s 23ms/step
1/1 [==============================] - 0s 23ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 28ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 23ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 29ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 23ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 31ms/step
1/1 [==============================] - 0s 31ms/step
Inverse Transform Predictions:

# Inverse transform the predictions to get actual sales values
future_predictions =
scaler.inverse_transform(np.array(future_predictions).reshape(-1, 1))
Display Predictions:
# Display the predictions for the next 24 months
print(f'Predictions for the next 24 months: {future_predictions}')
Predictions for the next 24 months: [[13.525593 ]
[13.94045 ]
[14.161354 ]
[14.346481 ]
[14.5128765]
[14.775693 ]
[14.8436775]
[14.963552 ]
[15.025752 ]
[15.252812 ]
[15.261148 ]
[15.34032 ]
[15.458272 ]
[15.556854 ]
[15.646535 ]
[15.729873 ]
[15.808032 ]
[15.8783865]
[15.947483 ]
[16.013062 ]
[16.07672 ]
[16.133318 ]
[16.190027 ]
[16.244 ]]
# Plotting training loss
plt.plot(model_fit.history['loss'], label='Training Loss')
plt.title('Training Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.show()

Code Word File

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Code Word File

Uploaded by

Copyright:

Available Formats

Amazon ARMA model

Loading and Visualizing Data

df = pd.read_csv("AMZN.csv", parse_dates=['Date'], index_col='Date')

# Visualizing the closing prices over time using matplotlib.

import matplotlib.pyplot as plt

plt.plot(closing_prices, label='Closing Prices')

plt.title('Amazon Stock Closing Prices Over Time')

train, test = closing_prices[:train_size], closing_prices[train_size:]

Time Series Analysis

from statsmodels.graphics.tsaplots import plot_acf, plot_pacf

from statsmodels.tsa.stattools import adfuller

Making Data stationary

# Visualizing the differenced data

plt.plot(train_diff, label='1st Order Differenced Closing Prices')

plt.title('1st Order Differenced Amazon Stock Closing Prices')

plt.ylabel('Differenced Closing Price')

Auto ARMA Model

# Use auto_arima to find the best model

model = auto_arima(train_diff, suppress_warnings=True, seasonal=False)

# Get the best order

print("Best Order:", best_order)

Best Order: (2, 0, 2)

from statsmodels.tsa.arima.model import ARIMA

# Fit ARMA model with the best order

model = ARIMA(train_diff, order=(p, 0, q))

# Check AIC and BIC values

# Check the residuals for randomness and stationarity

plt.title('Residuals of ARMA Model')

# Plot actual vs predicted values for the test set

plt.plot(test.index, test.values, label='Actual')

plt.plot(test.index, forecast, label='Predicted')

from sklearn.metrics import mean_squared_error, mean_absolute_error

mse = mean_squared_error(test, forecast)

mae = mean_absolute_error(test, forecast)

print(f'Mean Squared Error (MSE): {mse}')

Forecasting the closing value

next_day = last_observation + pd.Timedelta(days=1)

print(f'Predicted Closing Value for {next_day.date()}: {predicted_next_day}')

Predicted Closing Value for 2023-02-18: 0.3408541885702173

from scipy.fft import fft

import matplotlib.pyplot as plt

closing_prices = df['Close'].values # Convert pandas Series to NumPy array

# Compute the FFT

# Plot the PSD

plt.title('Power Spectral Density (PSD)')

# Compute the spectrogram

frequencies, times, spectrogram_values = spectrogram(closing_prices)

print("times shape:", times.shape)

print("spectrogram_values.T shape:", spectrogram_values.T.shape)

# Plot the spectrogram

plt.pcolormesh(times, frequencies, np.log(spectrogram_values + 1e-10),

AMAZON neural network

Import Libraries and Load Data

from sklearn.preprocessing import MinMaxScaler

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, LSTM

from sklearn.metrics import mean_squared_error

import matplotlib.pyplot as plt

Load and Preprocess Data

# Normalize the data

scaler = MinMaxScaler(feature_range=(0, 1))

# Create a function to prepare the data for the LSTM model