Deep learning With Tensor Flow Lab Manual
DEPARTMENT OF
Computer Science And Engineering
Artificial Intelligence And Data Science
III B Tech II Sem
DEEP LEARNING WITH TENSORFLOW
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
List of Experiments:
1. Implement multilayer perceptron algorithm for MNIST Hand written Digit Classification.
2. Design a neural network for classifying movie reviews (Binary Classification) using IMDB
dataset.
3. Design a neural Network for classifying news wires (Multi class classification) using Reuters
dataset.
4. Design a neural network for predicting house prices using Boston Housing Price dataset.
5. Build a Convolution Neural Network for MNIST Hand written Digit Classification.
6. Build a Convolution Neural Network for simple image (dogs and Cats) Classification
7. Use a pre-trained convolution neural network (VGG16) for image classification.
8. Implement one hot encoding of words or characters.
9. Implement word embeddings for IMDB dataset.
10. Implement a Recurrent Neural Network for IMDB movie review classification problem.
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
3
1.Implement multilayer perceptron algorithm for MNIST Hand written Digit Classification
import numpy as np
from tensorflow import keras
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
# Load and preprocess the MNIST dataset
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Normalize the pixel values to the range [0, 1]
x_train = x_train / 255.0
x_test = x_test / 255.0
# Flatten the images into 1D arrays
x_train = x_train.reshape((-1, 28*28))
x_test = x_test.reshape((-1, 28*28))
# Convert labels to one-hot encoding
num_classes = 10
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
# Define the MLP model
model = Sequential([
Dense(128, activation='relu', input_shape=(784,)),
Dense(64, activation='relu'),
Dense(10, activation='softmax')
])
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
# Compile the model
4
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# Train the model
model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2)
# Evaluate the model
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Test accuracy: {test_acc}')
2.Design a neural network for classifying movie reviews (Binary Classification) using IMDB dataset.
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense
vocab_size = 10000 # Assuming vocabulary size
embedding_dim = 128
max_length = 200 # Maximum length of input sequences
model = Sequential([
Embedding(vocab_size, embedding_dim, input_length=max_length),
LSTM(128),
Dense(1, activation='sigmoid')
])
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=5, batch_size=32, validation_data=(X_val, y_val))
loss, accuracy = model.evaluate(X_test, y_test)
print("Test Accuracy:", accuracy)
3.Design a neural Network for classifying news wires (Multi class classification) using Reuters dataset.
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
import numpy as np
5
from tensorflow.keras.datasets import reuters
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Activation
from tensorflow.keras.utils import to_categorical
# Load Reuters dataset
(x_train, y_train), (x_test, y_test) = reuters.load_data(num_words=10000)
# Pad sequences to a fixed length
from tensorflow.keras.preprocessing.sequence import pad_sequences
maxlen = 200
x_train = pad_sequences(x_train, maxlen=maxlen)
x_test = pad_sequences(x_test, maxlen=maxlen)
# Convert labels to one-hot encoding
num_classes = np.max(y_train) + 1
y_train = to_categorical(y_train, num_classes)
y_test = to_categorical(y_test, num_classes)
# Define model
model = Sequential()
model.add(Dense(512, input_shape=(maxlen,)))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes))
model.add(Activation('softmax'))
# Compile model
model.compile(loss='categorical_crossentropy',
optimizer='adam',
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
metrics=['accuracy'])
6
# Train model
batch_size = 32
epochs = 10
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))
# Evaluate model
score = model.evaluate(x_test, y_test, batch_size=batch_size)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
4. Design a neural network for predicting house prices using Boston Housing Price dataset.
import numpy as np
import pandas as pd
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from keras.models import Sequential
from keras.layers import Dense
# Load the Boston Housing Price dataset
boston = load_boston()
X = boston.data
y = boston.target
# Split the dataset into training and testing sets
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
7
# Standardize the features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# Define the neural network architecture
model = Sequential()
model.add(Dense(64, activation='relu', input_shape=(X_train.shape[1],)))
model.add(Dense(32, activation='relu'))
model.add(Dense(1))
# Compile the model
model.compile(optimizer='adam', loss='mean_squared_error')
# Train the model
history = model.fit(X_train_scaled, y_train, epochs=100, batch_size=32, validation_split=0.1, verbose=1)
# Evaluate the model
train_loss = model.evaluate(X_train_scaled, y_train, verbose=0)
test_loss = model.evaluate(X_test_scaled, y_test, verbose=0)
print(f"Train Loss: {train_loss:.4f}")
print(f"Test Loss: {test_loss:.4f}")
5. Build a Convolution Neural Network for MNIST Hand written Digit Classification.
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
# Load the MNIST dataset
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
8
# Reshape and normalize the images
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255
# Convert labels to categorical one-hot encoding
train_labels = tf.keras.utils.to_categorical(train_labels)
test_labels = tf.keras.utils.to_categorical(test_labels)
# Define the CNN architecture
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
# Compile the model
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
# Train the model
model.fit(train_images, train_labels, epochs=5, batch_size=64, validation_split=0.2)
# Evaluate the model on test data
test_loss, test_acc = model.evaluate(test_images, test_labels)
print('Test accuracy:', test_acc)
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
9
6. Build a Convolution Neural Network for simple image (dogs and Cats) Classification
import tensorflow as tf
from tensorflow.keras import layers, models
# Define the CNN model
def create_model():
model = models.Sequential([
# Convolutional layer with 32 filters, kernel size 3x3, and ReLU activation function
layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)),
# Max pooling layer with pool size 2x2
layers.MaxPooling2D((2, 2)),
# Convolutional layer with 64 filters, kernel size 3x3, and ReLU activation function
layers.Conv2D(64, (3, 3), activation='relu'),
# Max pooling layer with pool size 2x2
layers.MaxPooling2D((2, 2)),
# Convolutional layer with 128 filters, kernel size 3x3, and ReLU activation function
layers.Conv2D(128, (3, 3), activation='relu'),
# Max pooling layer with pool size 2x2
layers.MaxPooling2D((2, 2)),
# Convolutional layer with 128 filters, kernel size 3x3, and ReLU activation function
layers.Conv2D(128, (3, 3), activation='relu'),
# Max pooling layer with pool size 2x2
layers.MaxPooling2D((2, 2)),
# Flatten layer to convert 3D output to 1D
layers.Flatten(),
# Dense (fully connected) layer with 512 units and ReLU activation function
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
layers.Dense(512, activation='relu'),
10
# Output layer with 1 unit (binary classification) and sigmoid activation function
layers.Dense(1, activation='sigmoid')
])
# Compile the model
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
return model
# Create the CNN model
model = create_model()
# Display the model architecture
model.summary()
7. Use a pre-trained convolution neural network (VGG16) for image classification.
import numpy as np
from keras.applications import VGG16
from keras.preprocessing import image
from keras.applications.vgg16 import preprocess_input, decode_predictions
# Load the pre-trained VGG16 model
model = VGG16(weights='imagenet')
# Load and preprocess the image
img_path = 'your_image.jpg'
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
x = np.expand_dims(x, axis=0)
11
x = preprocess_input(x)
# Use the model to make predictions
predictions = model.predict(x)
# Decode and print the top-3 predicted classes
decoded_predictions = decode_predictions(predictions, top=3)[0]
print('Predictions:')
for i, (imagenet_id, label, score) in enumerate(decoded_predictions):
print(f"{i + 1}: {label} ({score:.2f})")
8. Implement one hot encoding of words or characters.
import numpy as np
def one_hot_encode_words(text):
words = text.split()
unique_words = sorted(set(words))
word_to_index = {word: i for i, word in enumerate(unique_words)}
num_words = len(unique_words)
encoding = np.zeros((len(words), num_words))
for i, word in enumerate(words):
encoding[i, word_to_index[word]] = 1
return encoding, unique_words
def one_hot_encode_characters(text):
characters = list(text)
unique_characters = sorted(set(characters))
char_to_index = {char: i for i, char in enumerate(unique_characters)}
num_chars = len(unique_characters)
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
encoding = np.zeros((len(characters), num_chars))
12
for i, char in enumerate(characters):
encoding[i, char_to_index[char]] = 1
return encoding, unique_characters
# Example usage
text = "one hot encoding example"
word_encoding, unique_words = one_hot_encode_words(text)
print("Word Encoding:")
print(word_encoding)
print("Unique Words:")
print(unique_words)
char_encoding, unique_chars = one_hot_encode_characters(text)
print("\nCharacter Encoding:")
print(char_encoding)
print("Unique Characters:")
print(unique_chars)
9. Implement word embeddings for IMDB dataset.
import tensorflow as tf
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Flatten, Dense
# Load the IMDB dataset
vocab_size = 10000
max_len = 200
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
embedding_dim = 50
13
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)
# Pad sequences to ensure uniform length
x_train = pad_sequences(x_train, maxlen=max_len)
x_test = pad_sequences(x_test, maxlen=max_len)
# Build the model
model = Sequential()
model.add(Embedding(vocab_size, embedding_dim, input_length=max_len))
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
# Train the model
history = model.fit(x_train, y_train,
epochs=10,
batch_size=32,
validation_data=(x_test, y_test))
# Evaluate the model
loss, accuracy = model.evaluate(x_test, y_test)
print("Test Accuracy:", accuracy)
10. Implement a Recurrent Neural Network for IMDB movie review classification problem.
import numpy as np
from tensorflow.keras.datasets import imdb
from tensorflow.keras.models import Sequential
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
from tensorflow.keras.layers import Embedding, SimpleRNN, Dense
14
from tensorflow.keras.preprocessing.sequence import pad_sequences
# Set parameters
max_features = 10000 # Number of words to consider as features
maxlen = 500 # Cuts off reviews after this number of words
batch_size = 32
# Load data
print('Loading data...')
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')
# Preprocess data
print('Pad sequences (samples x time)')
x_train = pad_sequences(x_train, maxlen=maxlen)
x_test = pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)
# Define model
model = Sequential()
model.add(Embedding(max_features, 32)) # Embedding layer
model.add(SimpleRNN(32)) # RNN layer
model.add(Dense(1, activation='sigmoid')) # Output layer
# Compile model
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc'])
# Train model
print('Training model...')
history = model.fit(x_train, y_train,
PITM Dept.CSE
Deep learning With Tensor Flow Lab Manual
epochs=10,
15
batch_size=batch_size,
validation_split=0.2)
# Evaluate model
print('Evaluating model...')
loss, accuracy = model.evaluate(x_test, y_test, batch_size=batch_size)
print('Test loss:', loss)
print('Test accuracy:', accuracy)
PITM Dept.CSE
