Using the following code Install Packages pip install .pdf

Using the following code:
##Install Packages
!pip install tensorflow
!pip install matplotlib
!pip install numpy
!pip install pandas
##Import Statements
from datetime import datetime, timedelta
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
##Bringing in our dataset
url= 'https://raw.githubusercontent.com/BeeDrHU/Introduction-to-Python-CSPC-323-
/main/sales_forecast.csv'
data = pd.read_csv(url, sep=',')
##Filtering and Cleaning
data= data[['Store', 'Date', 'Temperature', 'Fuel_Price', 'CPI' , 'Unemployment', 'Weekly_Sales',
'IsHoliday_y']]
data['Date'] = pd.to_datetime(data['Date'], format='%d/%m/%Y')
data = data.set_index('Date')
data = data.sort_index()
##Checklist and Quality Assurance
data.isnull()
print(f'Number of rows with missing values: {data.isnull().any(axis=1).mean()}')
data.info()
##Subsetting variable to predict
df= data['Weekly_Sales']
df.plot()
##Train and Test Split
start_train = datetime(2010, 2, 5)
end_train = datetime(2011, 12, 30)
end_test = datetime(2012, 7, 13)
msk_train = (data.index >= start_train) & (data.index <= end_train)
msk_test = (data.index >= end_train) & (data.index <= end_test)
df_train = df.loc[msk_train]
df_test = df.loc[msk_test]
df_train.plot()
df_test.plot()
##Normalizing our data
uni_data= df.values.astype(float)
df_train= int(len(df_train))

uni_train_mean= uni_data[:df_train].mean()
uni_train_std= uni_data[:df_train].std()
uni_data= (uni_data-uni_train_mean)/uni_train_std
##Build the features dataset to make the model multivariate
features_considered = ['Temperature', 'Fuel_Price', 'CPI']
features = data[features_considered]
features.index = data.index
##Standardizing the Data
dataset = features.values
data_mean = dataset[:df_train].mean(axis=0)
data_std = dataset[:df_train].std(axis=0)
dataset = (dataset-data_mean)/data_std
##Splitting data into training and testing
x_train = dataset[msk_train]
y_train = uni_data[:df_train]
x_test = dataset[msk_test]
y_test = uni_data[df_train:]
##Defining the model architecture
model = tf.keras.models.Sequential([
tf.keras.layers.Dense(64, activation='relu', input_shape=[x_train.shape[1]]),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(1)
])
##Compiling the model
model.compile(optimizer=tf.keras.optimizers.RMSprop(),
loss='mae')
##Fitting the model to the training data
history = model.fit(x_train, y_train,
epochs=100,
batch_size=64,
validation_split=0.2,
verbose=0)
##Evaluating the model on the test data
results = model.evaluate(x_test, y_test, verbose=0)
print(f'Test loss: {results}')
##Making predictions on new data
predictions = model.predict(x_test)
##Plotting the results
fig, ax = plt.subplots(figsize=(10,5))
ax.plot(np.arange(len(y_test)), y_test, label='Actual')
ax.plot(np.arange(len(predictions)), predictions, label='Predicted')
ax.legend()

plt.title('Actual vs Predicted Weekly Sales')
plt.xlabel('Week')
plt.ylabel('Normalized Sales')
plt.show()
*BUILD the RNN*
##Defining Function to Build Multivariate Data Structure
def multivariate_data(dataset, target, start_index, end_index, history_size,
target_size, step, single_step=False):
data = []
labels = []
start_index = start_index + history_size
if end_index is None:
end_index = len(dataset) - target_size
for i in range(start_index, end_index):
indices = range(i-history_size, i, step)
data.append(dataset[indices])
if single_step:
labels.append(target[i+target_size])
else:
labels.append(target[i:i+target_size])
return np.array(data), np.array(labels)
##Define the Multi-step Plotting Structure
def multi_step_plot(history, true_future, prediction):
plt.figure(figsize=(12, 6))
num_in = create_time_steps(len(history))
num_out = len(true_future)
plt.plot(num_in, np.array(history[:, 1]), label='History')
plt.plot(np.arange(num_out)/STEP, np.array(true_future), 'bo',
label='True Future')
if prediction.any():
plt.plot(np.arange(num_out)/STEP, np.array(prediction), 'ro',
label='Predicted Future')
plt.legend(loc='upper left')
plt.show()
##Define Function to Plot training and Validation over Time
def plot_train_history(history, title):
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(loss))
plt.figure()
plt.plot(epochs, loss, 'b', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')

plt.title(title)
plt.legend()
plt.show()
##How far into the past do you want the model to see?
past_history=
##How far into the future do you want the model to see?
future_target=
##
STEP=
df_val = len(dataset) - past_history - future_target
x_train_multi, y_train_multi = multivariate_data(dataset, dataset[:, 1], 0,
df_train, past_history,
future_target, STEP)
x_val_multi, y_val_multi = multivariate_data(dataset, dataset[:, 1],
df_train, df_val, past_history,
future_target, STEP)
##Define Constants
BATCH_SIZE =
BUFFER_SIZE =
EPOCHS =
EVALUATION_INTERVAL =
##Adding Layers Due to Complexity
train_data_multi = tf.data.Dataset.from_tensor_slices(())
train_data_multi = train_data_multi.cache().shuffle().batch().repeat()
val_data_multi = tf.data.Dataset.from_tensor_slices(())
val_data_multi = val_data_multi.batch().repeat()
multi_step_model = tf.keras.models.Sequential()
multi_step_model.add(tf.keras.layers.LSTM())
multi_step_model.add(tf.keras.layers.LSTM())
multi_step_model.add(tf.keras.layers.Dense(72))
multi_step_model.compile(optimizer=tf.keras.optimizers.RMSprop(clipvalue=1.0), loss='mae')
##Train the Model
multi_step_history = multi_step_model.fit(train_data_multi, epochs=,
steps_per_epoch=,
validation_data=,
validation_steps=50)
##Predict Future Data
for x, y in .take(3):
multi_step_plot(x[0], y[0], .predict(x)[0])
#Evaluate the model on the test data
test_data_multi = tf.data.Dataset.from_tensor_slices())

test_data_multi = test_data_multi.batch()
# Define the number of steps in the test dataset
steps = len()
mae_values = []
for x, y in :
x_val, y_val= x[:, :-1], y[:,-1]
#Make predictions using the model
= .predict(x_val, steps=steps)
#Compute MAE
mae = tf.keras.metrics.mean_absolute_error().numpy()
mae_values.append(mae)
overall_mae = np.mean(mae_values)
print('Overall MAE:', overall_mae)
*Based on the model accuracy, do you think the features you selected to include in the RNN were
a good choice? What other features do you think could improve the model? Can be real or
theoretical features you're interested in.
If you had to keep the same features that are currently included in your model, what technique(s)
could you use to optimize the model? Explain what these techniques are doing to determine the
optimal model state.*

Using the following code Install Packages pip install .pdf

More Related Content

Similar to Using the following code Install Packages pip install .pdf (20)

More from picscamshoppe (20)

Recently uploaded (20)

Using the following code Install Packages pip install .pdf