Scribd
Upload
2 views26 pages

Deep Learning Projects: Autoencoders, CNNs, RNNs

The document outlines practical implementations of various deep learning models using TensorFlow, including an autoencoder for image reconstruction, a CNN for classifying the MNIST dataset, an RNN/LSTM for time series forecasting, and a feedforward neural network for classifying news topics and estimating housing prices. Additionally, it includes a model for classifying movie reviews as positive or negative using the IMDB dataset. Each section provides code snippets, model architecture, training processes, and evaluation metrics.

Uploaded by

riy05
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
2 views26 pages

Deep Learning Projects: Autoencoders, CNNs, RNNs

The document outlines practical implementations of various deep learning models using TensorFlow, including an autoencoder for image reconstruction, a CNN for classifying the MNIST dataset, an RNN/LSTM for time series forecasting, and a feedforward neural network for classifying news topics and estimating housing prices. Additionally, it includes a model for classifying movie reviews as positive or negative using the IMDB dataset. Each section provides code snippets, model architecture, training processes, and evaluation metrics.

Uploaded by

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

DEEP LEARNING PRACTICAL

1. Implement an autoencoder
import numpy as np
import [Link] as plt
import tensorflow as tf
from [Link] import mnist
from [Link] import Sequential
from [Link] import Dense, Flatten, Reshape
from sklearn.model_selection import train_test_split

(x_train, _), (x_test, _) = mnist.load_data()

x_train = x_train.astype("float32") / 255.0


x_test = x_test.astype("float32") / 255.0

x_train = x_train.reshape(-1, 28*28)


x_test = x_test.reshape(-1, 28*28)
x_train, x_valid = train_test_split(x_train, test_size=0.2,
random_state=42)

encoding_dim = 64

model = Sequential([
Dense(128, activation='relu', input_shape=(784,)),
Dense(encoding_dim, activation='relu'),
Dense(128, activation='relu'),
Dense(784, activation='sigmoid'),
Reshape((28, 28))
])

[Link](optimizer="adam", loss="mse")

history = [Link](
x_train, x_train.reshape(-1, 28, 28),
validation_data=(x_valid, x_valid.reshape(-1, 28, 28)),
epochs=20,
batch_size=256,
verbose=1
)

[Link]([Link]['loss'], label='train loss')


[Link]([Link]['val_loss'], label='val loss')
[Link]("Epoch")
[Link]("Loss")
[Link]("Autoencoder Training Curve")
[Link]()
[Link]()

decoded_imgs = [Link](x_test[:10])

[Link](figsize=(12,4))
for i in range(10):
[Link](2,10,i+1)
[Link](x_test[i].reshape(28,28), cmap="gray")
[Link]('off')
[Link](2,10,i+11)
[Link](decoded_imgs[i], cmap="gray")
[Link]('off')
[Link]()

2. IMPLEMENT CNN FOR CLASSIFYING MNIST DATASET


import numpy as np
import [Link] as plt
import tensorflow as tf
from [Link] import mnist
from [Link] import to_categorical
from [Link] import Sequential
from [Link] import Conv2D, MaxPooling2D,
Flatten, Dense, Dropout
from sklearn.model_selection import train_test_split
from [Link] import classification_report,
accuracy_score

(x_train, y_train), (x_test, y_test) = mnist.load_data()

x_train = x_train.reshape(-1, 28, 28, 1).astype("float32") / 255.0


x_test = x_test.reshape(-1, 28, 28, 1).astype("float32") / 255.0

x_train, x_valid, y_train, y_valid = train_test_split(


x_train, y_train, test_size=0.2, random_state=42,
stratify=y_train
)

y_train_cat = to_categorical(y_train, 10)


y_valid_cat = to_categorical(y_valid, 10)

model = Sequential([
Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),
MaxPooling2D((2,2)),
Conv2D(64, (3,3), activation='relu'),
MaxPooling2D((2,2)),
Flatten(),
Dense(128, activation='relu'),
Dropout(0.3),
Dense(10, activation='softmax')
])
[Link](optimizer="adam",
loss="categorical_crossentropy", metrics=["accuracy"])

history = [Link](
x_train, y_train_cat,
validation_data=(x_valid, y_valid_cat),
epochs=10,
batch_size=64,
verbose=1
)

[Link]([Link]['loss'], label='train loss')


[Link]([Link]['val_loss'], label='val loss')
[Link]("Epoch")
[Link]("Loss")
[Link]("Training Curve")
[Link]()
[Link]()
preds = [Link](x_test)
pred_labels = [Link](preds, axis=1)

acc = accuracy_score(y_test, pred_labels)


print("Test Accuracy:", acc)
print(classification_report(y_test, pred_labels))

3. CREATE A MODEL FOR TIME SERIES FORECASTING USING


RNN/LSTM

import numpy as np
import [Link] as plt
import tensorflow as tf
from [Link] import Sequential
from [Link] import LSTM, SimpleRNN, Dense,
Dropout
from [Link] import MinMaxScaler
from [Link] import mean_squared_error,
mean_absolute_error
[Link](42)
[Link].set_seed(42)

t = [Link](0, 400, 0.1)


data = [Link](0.05 * t) + 0.05 * [Link](len(t))
data = [Link](-1, 1)

scaler = MinMaxScaler()
data_scaled = scaler.fit_transform(data)

def create_dataset(series, step):


X, y = [], []
for i in range(len(series) - step):
[Link](series[i:i+step])
[Link](series[i+step])
return [Link](X), [Link](y)

time_steps = 30
X, y = create_dataset(data_scaled, time_steps)
X_train, X_test = X[:3000], X[3000:]
y_train, y_test = y[:3000], y[3000:]

model = Sequential([
LSTM(64, return_sequences=True, input_shape=(time_steps,
1)),
Dropout(0.2),
LSTM(32),
Dropout(0.2),
Dense(1)
])

[Link](optimizer="adam", loss="mse")
history = [Link](X_train, y_train, epochs=20, batch_size=32,
validation_split=0.2, verbose=1)

[Link]([Link]['loss'], label='train loss')


[Link]([Link]['val_loss'], label='val loss')
[Link]()
[Link]("Epoch")
[Link]("MSE Loss")
[Link]("Training Curve")
[Link]()

preds = [Link](X_test)
preds_actual = scaler.inverse_transform(preds)
y_test_actual = scaler.inverse_transform(y_test)

mse = mean_squared_error(y_test_actual, preds_actual)


mae = mean_absolute_error(y_test_actual, preds_actual)
rmse = [Link](mse)

print("MSE:", mse)
print("RMSE:", rmse)
print("MAE:", mae)

[Link](figsize=(10,4))
[Link](y_test_actual[:200], label="True")
[Link](preds_actual[:200], label="Predicted")
[Link]()
[Link]("Forecast vs Actual")
[Link]()

4. IMPLEMENT A DEEP NEURAL NETWORK FOR


CLASSIFYING NEWS WIRES BY TOPIC ( REUTERS
DATASET )

# Run in Jupyter. If needed: !pip install -q tensorflow scikit-learn


matplotlib

import numpy as np
import [Link] as plt
from sklearn.model_selection import train_test_split
from [Link] import classification_report,
accuracy_score, confusion_matrix
import tensorflow as tf
from [Link] import reuters
from [Link] import
pad_sequences
from [Link] import to_categorical
from [Link] import Sequential
from [Link] import Embedding,
GlobalAveragePooling1D, Dense, Dropout
from [Link] import Adam
[Link](42)
[Link].set_seed(42)

vocab_size = 10000
max_len = 200
embedding_dim = 128
batch_size = 32
epochs = 15
learning_rate = 1e-3

(x_train_full, y_train_full), (x_test, y_test) =


reuters.load_data(num_words=vocab_size)

x_train, x_valid, y_train, y_valid = train_test_split(


x_train_full, y_train_full, test_size=0.20, random_state=42,
stratify=y_train_full
)

x_train = pad_sequences(x_train, maxlen=max_len,


padding='post', truncating='post')
x_valid = pad_sequences(x_valid, maxlen=max_len,
padding='post', truncating='post')
x_test = pad_sequences(x_test, maxlen=max_len,
padding='post', truncating='post')

num_classes = [Link](y_train_full) + 1
y_train_cat = to_categorical(y_train, num_classes)
y_valid_cat = to_categorical(y_valid, num_classes)

model = Sequential([
Embedding(input_dim=vocab_size,
output_dim=embedding_dim, input_length=max_len),
GlobalAveragePooling1D(),
Dense(256, activation='relu'),
Dropout(0.4),
Dense(128, activation='relu'),
Dropout(0.3),
Dense(num_classes, activation='softmax')
])

[Link](optimizer=Adam(learning_rate),
loss='categorical_crossentropy', metrics=['accuracy'])
[Link]()

def plot_training(history, title="Training"):


hist = [Link]
epochs_range = range(1, len(hist['loss']) + 1)
[Link](figsize=(12,4))
[Link](1,2,1)
[Link](epochs_range, hist['loss'], label='train loss')
[Link](epochs_range, [Link]('val_loss', []), label='val loss')
[Link]('Epoch'); [Link]('Loss'); [Link]();
[Link](f"{title} — Loss")
[Link](1,2,2)
[Link](epochs_range, hist['accuracy'], label='train acc')
[Link](epochs_range, [Link]('val_accuracy', []), label='val
acc')
[Link]('Epoch'); [Link]('Accuracy'); [Link]();
[Link](f"{title} — Accuracy")
plt.tight_layout(); [Link]()

def evaluate_model(model, x_test, y_test):


probs = [Link](x_test, batch_size=512, verbose=0)
preds = [Link](probs, axis=1)
print("Test accuracy (sklearn):", accuracy_score(y_test,
preds))
print("\nClassification report:\n")
print(classification_report(y_test, preds, digits=4))
print("Confusion matrix:\n", confusion_matrix(y_test, preds))

history = [Link](
x_train, y_train_cat,
validation_data=(x_valid, y_valid_cat),
epochs=epochs,
batch_size=batch_size,
verbose=1
)

plot_training(history, "Reuters Topic Classification")


evaluate_model(model, x_test, y_test)

5. IMPLEMENT A DEEP NEURAL FEED FORWARD NETWORK


FOR ESTIMATING THE PRICE OF HOUSE , GIVEN REAL
ESTATE DATA (BOSTON HOUSING PRICE )

import numpy as np
import [Link] as plt
from sklearn.model_selection import train_test_split
from [Link] import StandardScaler
import tensorflow as tf
from [Link] import boston_housing
from [Link] import Sequential
from [Link] import Dense, Dropout
from [Link] import Adam
from [Link] import mean_squared_error,
mean_absolute_error

(x_train, y_train), (x_test, y_test) = boston_housing.load_data()

scaler = StandardScaler()
x_train = scaler.fit_transform(x_train)
x_test = [Link](x_test)

x_train, x_valid, y_train, y_valid = train_test_split(


x_train, y_train, test_size=0.2, random_state=42
)

model = Sequential([
Dense(128, activation='relu',
input_shape=(x_train.shape[1],)),
Dropout(0.2),
Dense(64, activation='relu'),
Dropout(0.2),
Dense(32, activation='relu'),
Dense(1)
])

[Link](optimizer=Adam(0.001), loss='mse',
metrics=['mae'])

history = [Link](
x_train, y_train,
validation_data=(x_valid, y_valid),
epochs=50,
batch_size=32,
verbose=1
)

[Link]([Link]['loss'], label='train loss')


[Link]([Link]['val_loss'], label='val loss')
[Link]()
[Link]("Epoch")
[Link]("MSE Loss")
[Link]("Training Curve")
[Link]()

preds = [Link](x_test).flatten()
mse = mean_squared_error(y_test, preds)
mae = mean_absolute_error(y_test, preds)
rmse = [Link](mse)

print("MSE:", mse)
print("RMSE:", rmse)
print("MAE:", mae)

6. IMPLEMENT A FEED FORWARD NEURAL NETWORK FOR


CLASSIFYING MOVIE REVIEWS AS POSITIVE OR
NEGATIVE ( USING IMBD DATASET )

# Ready-to-run corrected code for IMDB FFN (Keras)


# Run in Jupyter. If needed: !pip install -q tensorflow scikit-learn
matplotlib

import numpy as np
import [Link] as plt
from sklearn.model_selection import train_test_split
from [Link] import classification_report,
confusion_matrix, accuracy_score
import tensorflow as tf
from [Link] import imdb
from [Link] import
pad_sequences
from [Link] import Sequential
from [Link] import Embedding, Flatten, Dense,
Dropout
from [Link] import Adam

# --------------------------
# Hyperparameters
vocab_size = 10000
embedding_dim = 128
batch_size = 32
epochs = 10
learning_rate = 1e-5
# --------------------------

# 1) Load data
(x_train, y_train), (x_test, y_test) =
imdb.load_data(num_words=vocab_size)

# 2) Split train -> train + valid


x_train, x_valid, y_train, y_valid = train_test_split(
x_train, y_train, test_size=0.20, random_state=42,
stratify=y_train
)

# 3) Find max length (use training set)


max_len = max(len(seq) for seq in x_train)

# (Optional) set a sensible upper cap to avoid extremely long


sequences (uncomment if desired)
# max_len = min(max_len, 1000)

# 4) Pad sequences so all inputs are same length


x_train = pad_sequences(x_train, maxlen=max_len,
padding='post', truncating='post')
x_valid = pad_sequences(x_valid, maxlen=max_len,
padding='post', truncating='post')
x_test = pad_sequences(x_test, maxlen=max_len,
padding='post', truncating='post')

# 5) Build model
model = Sequential([
Embedding(input_dim=vocab_size,
output_dim=embedding_dim, input_length=max_len),
Flatten(),
Dense(512, activation='relu'),
Dropout(0.5),
Dense(256, activation='relu'),
Dropout(0.3),
Dense(128, activation='relu'),
Dropout(0.3),
Dense(64, activation='relu'),
Dropout(0.3),
Dense(1, activation='sigmoid')
])

# 6) Compile
optimizer = Adam(learning_rate=learning_rate)
[Link](optimizer=optimizer, loss='binary_crossentropy',
metrics=['accuracy'])

# 7) Build & summary (optional build call)


[Link](input_shape=(None, max_len))
[Link]()

# 8) Helper functions (plotting + evaluation)


def plot_training(history, title="Training"):
"""Plot loss and accuracy curves from Keras History."""
hist = [Link]
epochs_range = range(1, len(hist['loss']) + 1)

[Link](figsize=(12,4))
[Link](1,2,1)
[Link](epochs_range, hist['loss'], label='train loss')
[Link](epochs_range, [Link]('val_loss', []), label='val loss')
[Link](f"{title} — Loss")
[Link]('Epoch')
[Link]('Loss')
[Link]()

[Link](1,2,2)
[Link](epochs_range, hist['accuracy'], label='train acc')
[Link](epochs_range, [Link]('val_accuracy', []), label='val
acc')
[Link](f"{title} — Accuracy")
[Link]('Epoch')
[Link]('Accuracy')
[Link]()

plt.tight_layout()
[Link]()
def evaluate_model(model, x_test, y_test,
task_type="classification"):
"""Evaluate and print metrics for binary classification."""
loss, acc = [Link](x_test, y_test, verbose=0)
print(f"Test loss: {loss:.4f} Test accuracy: {acc:.4f}")

# Predictions -> binary labels


probs = [Link](x_test, batch_size=512, verbose=0)
preds = ([Link]() >= 0.5).astype(int)

print("\nClassification Report:")
print(classification_report(y_test, preds, digits=4))

print("Confusion Matrix:")
print(confusion_matrix(y_test, preds))

print("Overall accuracy (sklearn):", accuracy_score(y_test,


preds))
# 9) Train
history = [Link](
x_train, y_train,
validation_data=(x_valid, y_valid),
epochs=epochs,
batch_size=batch_size,
verbose=1
)

# 10) Plot training metrics


plot_training(history, "IMDB Sentiment")

# 11) Evaluate on test set


evaluate_model(model, x_test, y_test)

You might also like