Scribd
Upload
16 views

Gen AI

Wowowowow

Uploaded by

anindyachickoo.04
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
16 views

Gen AI

Wowowowow

Uploaded by

anindyachickoo.04
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 11

Introduction

Weather forecasting is an essential aspect of daily life, impacting various


sectors such as agriculture, transportation, and disaster management. Traditional
methods of forecasting often rely on statistical techniques and physical models
that can be limited in their accuracy. This project leverages Generative AI,
specifically Long Short-Term Memory (LSTM) networks, to create a more
accurate model for predicting weather conditions based on historical data.

1
Data Preprocessing
Overview
Data preprocessing is a critical step in any machine learning project. It involves
cleaning and transforming raw data into a format that can be effectively utilized
by machine learning algorithms. In this project, the dataset consists of historical
weather data, including features such as temperature, humidity, and pressure.

Implementation
The data preprocessing is handled in the load_and_preprocess_data function.
The following steps are performed:
Loading the Dataset: The dataset is loaded using Pandas, and the 'Date' column
is parsed as datetime and set as the index.
Feature Selection: Only relevant features (Temperature, Humidity, and
Pressure) are selected for the model.
Scaling the Data: The features are scaled to a range of 0 to 1 using
MinMaxScaler from Scikit-learn to ensure that all input values are within a
similar range, which aids in model convergence.

Code:
import pandas as pd
from sklearn.preprocessing import MinMaxScaler

def load_and_preprocess_data(file_path):
data = pd.read_csv(file_path, parse_dates=['Date'], index_col='Date')
features = ['Temperature', 'Humidity', 'Pressure']
data = data[features]
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(data)
return scaled_data, scaler

2
Model Training
Overview
The heart of the project is the training of the LSTM model, which is designed to
learn from sequential data. LSTM networks are particularly well-suited for
time-series forecasting due to their ability to remember past information.

Implementation
The model training occurs in the train_model function. The process includes:
Dataset Preparation: The data is transformed into a suitable format for LSTM by
creating time-series sequences.
Model Architecture: The LSTM model is constructed using Keras, consisting of
two LSTM layers followed by dense layers.
Model Compilation and Training: The model is compiled with the Adam
optimizer and mean squared error loss function, and trained using early stopping
to prevent overfitting.

Code:
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
from tensorflow.keras.callbacks import EarlyStopping

def create_dataset(data, time_step=1):


X, y = [], []
for i in range(len(data) - time_step - 1):
a = data[i:(i + time_step), 0]
X.append(a)
y.append(data[i + time_step, 0])
return np.array(X), np.array(y)
3
def train_model(data, time_step=10, epochs=50, batch_size=32):
X, y = create_dataset(data, time_step)
X = X.reshape(X.shape[0], X.shape[1], 1)
model = Sequential()
model.add(LSTM(50, return_sequences=True, input_shape=(time_step, 1)))
model.add(LSTM(50, return_sequences=False))
model.add(Dense(25))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mean_squared_error')
early_stop = EarlyStopping(monitor='loss', patience=5)
model.fit(X, y, epochs=epochs, batch_size=batch_size,
callbacks=[early_stop])
return model

4
Forecast Generation
Overview
Once the model is trained, it can be used to generate future weather forecasts.
The generate_forecast function handles this by taking the last observed data and
predicting future values.

Implementation
The forecast generation process involves:
Input Preparation: The last sequences of data are used to make predictions.
Forecast Loop: The model predicts the next value, updates the input with the
new prediction, and repeats the process for the desired forecast length.

Code:
import numpy as np

def generate_forecast(model, data, time_step=10, forecast_length=7):


temp_input = list(data[-time_step:])
lst_output = []
for i in range(forecast_length):
if len(temp_input) > time_step:
x_input = np.array(temp_input[1:])
x_input = x_input.reshape((1, time_step, 1))
yhat = model.predict(x_input, verbose=0)
temp_input.extend(yhat[0].tolist())
temp_input = temp_input[1:]
lst_output.extend(yhat.tolist())
else:
x_input = np.array(temp_input)
5
x_input = x_input.reshape((1, time_step, 1))
yhat = model.predict(x_input, verbose=0)
temp_input.extend(yhat[0].tolist())
lst_output.extend(yhat.tolist())
return lst_output

6
Project Structure
The project is organized into the following directory structure:
data/: Contains the weather dataset.
src/: Contains the source code:
data_preprocessing.py: Handles data loading and preprocessing.
model_training.py: Contains functions to train the LSTM model.
forecast_generation.py: Manages the generation of forecasts.
main.py: The main script to execute the project.
README.md: Provides project documentation.

7
How to Run the Project
To execute the project, follow these steps:
Clone the repository to your local machine.
Place your weather dataset in the data/ folder, ensuring it is in the correct
format.
Run the main script main.py to train the model and generate forecasts.

8
Requirements
To run this project, ensure you have the following installed:
Python 3.x
TensorFlow
Pandas
Scikit-learn

Code:
pip install tensorflow pandas scikit-learn

9
Conclusion
This project demonstrates the application of Generative AI, specifically LSTM
networks, in weather forecasting. By effectively preprocessing the data, training
a robust model, and generating accurate forecasts, the project showcases the
potential of AI in enhancing predictive analytics in meteorology.

10
References
 Research papers on LSTM networks and their applications in time-series
forecasting.
 Documentation for TensorFlow and Keras.
 Pandas and Scikit-learn documentation for data manipulation and
preprocessing techniques.

11

You might also like