rng = pd.date_range('2024-03-01', periods=50, freq='D')
rng

# Get the stock quote
df = pdr.get_data_yahoo('SPXL', start='2022-01-01', end=datetime.now())
# Show teh data
df.tail(10)

plt.figure(figsize=(16,6))
plt.title('Close Price History')
plt.plot(df['Close'])
plt.xlabel('Date', fontsize=18)
plt.ylabel('Close Price USD ($)', fontsize=18)
plt.show()

plt.figure(figsize=(16,6))
close_px = df['Close'].resample('B').ffill()
ewma60 = df['Close'].ewm(span=60).mean()
df['Close'].plot(label = 'Normal')
ewma60.plot(style='k-', label='EW MA')
close_px.rolling(60).mean().plot(label = 'MA 60')
plt.legend()

# Create a new dataframe with only the 'Close column 
data = df.filter(['Close'])
# Convert the dataframe to a numpy array
dataset = data.values
# Get the number of rows to train the model on
training_data_len = int(np.ceil( len(dataset) * .95 ))

training_data_len

# Scale the data
from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0,1))
scaled_data = scaler.fit_transform(dataset)

scaled_data[:10]

# Create the training data set 
# Create the scaled training data set
train_data = scaled_data[0:int(training_data_len), :]
# Split the data into x_train and y_train data sets
x_train = []
y_train = []

for i in range(60, len(train_data)):
    x_train.append(train_data[i-60:i, 0])
    y_train.append(train_data[i, 0])
    if i<= 61:
        print(x_train)
        print(y_train)
        print()
        
# Convert the x_train and y_train to numpy arrays 
x_train, y_train = np.array(x_train), np.array(y_train)

# Reshape the data
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
x_train.shape

from keras.models import Sequential
from keras.layers import Dense, LSTM

# Build the LSTM model
model = Sequential()
model.add(LSTM(128, return_sequences=True, input_shape= (x_train.shape[1], 1)))
model.add(LSTM(64, return_sequences=False))
model.add(Dense(25))
model.add(Dense(1))

# Compile the model
model.compile(optimizer='adam', loss='mean_squared_error')

# Train the model
model.fit(x_train, y_train, batch_size=1, epochs=1)

# Create the testing data set
# Create a new array containing scaled values from index 1543 to 2002 
test_data = scaled_data[training_data_len - 60: , :]
# Create the data sets x_test and y_test
x_test = []
y_test = dataset[training_data_len:, :]
for i in range(60, len(test_data)):
    x_test.append(test_data[i-60:i, 0])
    
# Convert the data to a numpy array
x_test = np.array(x_test)

# Reshape the data
x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1 ))

# Get the models predicted price values 
predictions = model.predict(x_test)
predictions = scaler.inverse_transform(predictions)

# Get the root mean squared error (RMSE)
rmse = np.sqrt(np.mean(((predictions - y_test) ** 2)))
rmse

# Plot the data
train = data[:training_data_len]
valid = data[training_data_len:]
valid['Predictions'] = predictions
# Visualize the data
plt.figure(figsize=(16,6))
plt.title('Model')
plt.xlabel('Date', fontsize=18)
plt.ylabel('Close Price USD ($)', fontsize=18)
plt.plot(train['Close'])
plt.plot(valid[['Close', 'Predictions']])
plt.legend(['Train', 'Val', 'Predictions'], loc='lower right')
plt.show()

valid.tail(10)

last_input_data = scaled_data[-5:]
last_input_data = np.reshape(last_input_data, (1, 5, 1))
forecast = model.predict(last_input_data)

# You'll need to inverse scale the forecasted values if you used MinMaxScaler
forecast = scaler.inverse_transform(forecast)
forecast

plt.figure(figsize=(12,6))
data_30d = data.iloc[-30:]

# Plot the original time series data
plt.plot(data_30d.index, data_30d['Close'], label='Original Data')

# Forecast values for the next 7 days
next_time_points = pd.date_range(start=data.index[-1], periods=8, freq='D')[1:]
forecast = []  # Store forecasted values
last_input_data = scaled_data[-5:].reshape((1, 5, 1))  # Last input data
for _ in range(7):
    # Forecast next value
    next_value = model.predict(last_input_data)
    # Store forecasted value
    forecast.append(next_value[0, 0])
    # Update last input data for the next iteration
    last_input_data = np.append(last_input_data[:, 1:, :], next_value.reshape(1, 1, 1), axis=1)

# Inverse scale the forecasted values
forecast = scaler.inverse_transform(np.array(forecast).reshape(-1, 1))

# Plot the forecasted values
plt.plot(next_time_points, forecast, label='Forecast', marker='o')

plt.xlabel('Date')
plt.ylabel('Close')
plt.xticks(rotation=45, fontsize=12)
plt.title('Forecast S&P500 for Next 7 Days')
plt.legend()
plt.show()