Neural Networks in Python: Code Examples and Explanations
Neural Networks in Python: Code Examples
Single Neuron and Perceptron Examples
import numpy as np
def neuron(x, w, b):
z = np.dot(x, w) + b
return 1 if z >= 0 else 0
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def single_neuron(x, w, b):
z = np.dot(x, w) + b
output = sigmoid(z)
return output
x = np.array([1, 0])
w = np.array([0.5, 0.5])
b = -0.2
print(“Step Output:”, neuron(x, w, b))
print(“Sigmoid Output:”, single_neuron(x, w, b))
import numpy as np
def perceptron(x, w, b):
z = np.dot(x, w) + b
return 1 if z >= 0 else 0
X = np.array([
[0,0],
[0,1],
[1,0],
[1,1]
])
w = np.array([1, 1])
b = -1.5
print(“AND:”)
for x in X:
print(x, “->”, perceptron(x, w, b))
b = -0.5
print(“OR:”)
for x in X:
print(x, “->”, perceptron(x, w, b))
Multilayer Perceptron with Grid Search
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
mlp = MLPClassifier(max_iter=2000, random_state=42)
param_grid = {
“hidden_layer_sizes”: [(10,), (50,)],
“activation”: [“relu”, “tanh”]
}
grid = GridSearchCV(mlp, param_grid, cv=5)
grid.fit(X_train, y_train)
print(“Best Parameters:”, grid.best_params_)
y_pred = grid.predict(X_test)
print(“Accuracy:”, accuracy_score(y_test, y_pred))
print(“Confusion Matrix:\n”, confusion_matrix(y_test, y_pred))
print(“Classification Report:\n”, classification_report(y_test, y_pred))
Denoising Autoencoder on MNIST
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Flatten, Dense, Reshape
(X_train, _), (X_test, _) = tf.keras.datasets.mnist.load_data()
X_train = X_train.astype(“float32”) / 255.0
X_test = X_test.astype(“float32”) / 255.0
noise = 0.3 * np.random.normal(size=X_train.shape)
X_train_noisy = np.clip(X_train + noise, 0, 1)
noise = 0.3 * np.random.normal(size=X_test.shape)
X_test_noisy = np.clip(X_test + noise, 0, 1)
model = Sequential([Flatten(input_shape=(28, 28)),
Dense(64, activation=”relu”),
Dense(784, activation=”sigmoid”),
Reshape((28, 28))])
model.compile(optimizer=”adam”, loss=”binary_crossentropy”)
model.fit(X_train_noisy, X_train,
epochs=10, batch_size=256,
validation_data=(X_test_noisy, X_test), verbose=1)
denoised = model.predict(X_test_noisy)
n = 5
plt.figure(figsize=(10, 6))
for i in range(n):
plt.subplot(3, n, i + 1)
plt.imshow(X_test_noisy[i], cmap=”gray”)
plt.title(“Noisy”)
plt.axis(“off”)
plt.subplot(3, n, i + 1 + n)
plt.imshow(denoised[i], cmap=”gray”)
plt.title(“Denoised”)
plt.axis(“off”)
plt.subplot(3, n, i + 1 + 2*n)
plt.imshow(X_test[i], cmap=”gray”)
plt.title(“Original”)
plt.axis(“off”)
plt.tight_layout()
plt.show()
Autoencoder for Image Compression
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
(X_train, _), (X_test, _) = tf.keras.datasets.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, 784)
X_test = X_test.reshape(-1, 784)
model = Sequential([
Dense(128, activation=”relu”, input_shape=(784,)),
Dense(32, activation=”relu”),
Dense(128, activation=”relu”),
Dense(784, activation=”sigmoid”)
])
model.compile(optimizer=”adam”, loss=”mse”)
model.fit(X_train, X_train, epochs=2, batch_size=28,
verbose=1)
encoder = Sequential(model.layers[:2])
compressed = encoder.predict(X_test)
reconstructed = model.predict(X_test)
print(“Original:”, X_test.shape)
print(“Compressed:”, compressed.shape)
print(“Reconstructed:”, reconstructed.shape)
n = 5
plt.figure(figsize=(10, 4))
for i in range(n):
plt.subplot(2, n, i + 1)
plt.imshow(X_test[i].reshape(28, 28), cmap=”gray”)
plt.title(“Original”)
plt.axis(“off”)
plt.subplot(2, n, i + n + 1)
plt.imshow(reconstructed[i].reshape(28, 28), cmap=”gray”)
plt.title(“Reconstructed”)
plt.axis(“off”)
plt.tight_layout()
plt.show()
Dense Neural Network for MNIST Classification
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Flatten, Dense
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()
X_train = X_train / 255.0
X_test = X_test / 255.0
model = Sequential([
Flatten(input_shape=(28, 28)),
Dense(128, activation=”relu”),
Dense(64, activation=”relu”),
Dense(10, activation=”softmax”)
])
model.compile(
optimizer=”adam”,
loss=”sparse_categorical_crossentropy”,
metrics=[“accuracy”]
)
history = model.fit(
X_train, y_train,
epochs=10,
validation_data=(X_test, y_test)
)
loss, accuracy = model.evaluate(X_test, y_test)
print(“Test Accuracy:”, accuracy)
plt.plot(history.history[“accuracy”])
plt.plot(history.history[“val_accuracy”])
plt.xlabel(“Epoch”)
plt.ylabel(“Accuracy”)
plt.legend([“Train”, “Test”])
plt.show()
CNN Epoch Comparison on MNIST
import tensorflow as tf
import time
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
(X_train, y_train), (X_test, y_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, 1)
X_test = X_test.reshape(-1, 28, 28, 1)
def create_model():
model = Sequential([
Conv2D(32, (3,3), activation=’relu’, input_shape=(28,28,1)),
Conv2D(32, (3,3), activation=’relu’), MaxPooling2D((2,2)),
Conv2D(64, (3,3), activation=’relu’),
Conv2D(64, (3,3), activation=’relu’), MaxPooling2D((2,2)),
Flatten(),
Dense(128, activation=’relu’),
Dense(10, activation=’softmax’)])
model.compile(
optimizer=’adam’,
loss=’sparse_categorical_crossentropy’,
metrics=[‘accuracy’])
return model
epochs_list = [5, 10, 20]
for ep in epochs_list:
print(“\nTraining for”, ep, “Epochs”)
model = create_model()
start = time.time()
history = model.fit(X_train, y_train,
epochs=ep, batch_size=28,
validation_data=(X_test, y_test), verbose=1)
end = time.time()
loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
print(“Epochs:”, ep)
print(“Test Accuracy:”, accuracy)
print(“Execution Time:”, round(end-start, 2), “seconds”)
Optimizer Comparison: SGD vs Adam
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Flatten, Dense
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()
X_train = X_train / 255.0
X_test = X_test / 255.0
model = Sequential([Flatten(input_shape=(28, 28)),
Dense(128, activation=”relu”), Dense(64, activation=”relu”),
Dense(10, activation=”softmax”)])
model.compile(optimizer=”adam”,
loss=”sparse_categorical_crossentropy”, metrics=[“accuracy”])
model.fit(X_train, y_train, epochs=5, batch_size=32, validation_split=0.1)
loss, accuracy = model.evaluate(X_test, y_test)
print(“Test Accuracy:”, accuracy)
pred = model.predict(X_test)
print(“Predicted:”, pred[0].argmax())
print(“Actual:”, y_test[0])
________________________________________________
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()
X_train = X_train / 255.0
X_test = X_test / 255.0
def create_model(optimizer):
model = Sequential([Flatten(input_shape=(28, 28)),
Dense(128, activation=”relu”), Dense(64, activation=”relu”),
Dense(10, activation=”softmax”)])
model.compile(optimizer=optimizer,
loss=”sparse_categorical_crossentropy”, metrics=[“accuracy”])
return model
model_sgd = create_model(“sgd”)
model_sgd.fit(X_train, y_train, epochs=5, batch_size=32, verbose=0)
_, acc_sgd = model_sgd.evaluate(X_test, y_test, verbose=0)
model_adam = create_model(“adam”)
model_adam.fit(X_train, y_train, epochs=5, batch_size=32, verbose=0)
_, acc_adam = model_adam.evaluate(X_test, y_test, verbose=0)
print(“SGD Accuracy:”, acc_sgd)
print(“Adam Accuracy:”, acc_adam)
Perceptron on Breast Cancer Dataset
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Perceptron
from sklearn.metrics import accuracy_score
data = load_breast_cancer()
X = data.data
y = data.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
model = Perceptron()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(“Accuracy:”, accuracy_score(y_test, y_pred))
__________________________________________________________________________________________
XOR Problem with a Small Neural Network
import numpy as np
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([0, 1, 1, 0])
model = Sequential([
Dense(8, activation=”relu”, input_shape=(2,)),
Dense(1, activation=”sigmoid”)
])
model.compile(
optimizer=”adam”,
loss=”binary_crossentropy”,
metrics=[“accuracy”]
)
model.fit(X, y, epochs=500, verbose=0)
predictions = model.predict(X)
print(predictions)
print(“\nBinary Predictions:”)
print((predictions > 0.5).astype(int))
Variational Autoencoder Training Loop
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.keras import Sequential, Input
from tensorflow.keras.layers import Dense
(x, _), _ = tf.keras.datasets.mnist.load_data()
x = x.reshape(-1, 784).astype(“float32”) / 255.0
encoder = Sequential([Input((784,)), Dense(256, activation=”relu”), Dense(32)])
decoder = Sequential([Input((16,)), Dense(256, activation=”relu”), Dense(784, activation=”sigmoid”)])
opt = tf.keras.optimizers.Adam()
for epoch in range(10):
for batch in tf.data.Dataset.from_tensor_slices(x).shuffle(60000).batch(256):
with tf.GradientTape() as tape:
mean, log_var = tf.split(encoder(batch), 2, axis=1)
out = decoder(mean + tf.exp(0.5 * log_var) * tf.random.normal(tf.shape(mean)))
kl = -0.5 * tf.reduce_mean(tf.reduce_sum(1 + log_var – mean**2 – tf.exp(log_var), axis=1))
loss = tf.reduce_mean(tf.keras.losses.binary_crossentropy(batch, out)) + kl / 784
v = encoder.trainable_variables + decoder.trainable_variables
opt.apply_gradients(zip(tape.gradient(loss, v), v))
print(“Epoch”, epoch + 1, “Loss =”, float(loss))
imgs = decoder.predict(tf.random.normal((10, 16))).reshape(-1, 28, 28)
for i in range(10):
plt.subplot(1, 10, i + 1)
plt.imshow(imgs[i], cmap=”gray”)
plt.axis(“off”)
plt.show()
Autoencoder Latent Representation
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
(X_train, _), (X_test, _) = tf.keras.datasets.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, 784)
X_test = X_test.reshape(-1, 784)
autoencoder = Sequential([
Dense(128, activation=”relu”, input_shape=(784,)),
Dense(32, activation=”relu”),
Dense(128, activation=”relu”),
Dense(784, activation=”sigmoid”)
])
autoencoder.compile(optimizer=”adam”, loss=”mse”)
autoencoder.fit(
X_train,
X_train,
epochs=5,
batch_size=28
)
encoder = Sequential(autoencoder.layers[:2])
latent = encoder.predict(X_test)
print(“Original shape:”, X_test.shape)
print(“Latent shape:”, latent.shape)
print(latent)
CNN with Batch Normalization on MNIST
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import (
Conv2D, MaxPooling2D, BatchNormalization,
Flatten, Dense
)
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()
X_train = X_train.reshape(-1, 28, 28, 1) / 255.0
X_test = X_test.reshape(-1, 28, 28, 1) / 255.0
model = Sequential([
Conv2D(32, (3,3), padding=”same”, activation=”relu”, input_shape=(28,28,1)),
BatchNormalization(),
MaxPooling2D(),
Conv2D(64, (3,3), padding=”same”, activation=”relu”),
BatchNormalization(),
MaxPooling2D(),
Flatten(),
Dense(64, activation=”relu”),
Dense(10, activation=”softmax”)
])
model.compile(
optimizer=”adam”,
loss=”sparse_categorical_crossentropy”,
metrics=[“accuracy”]
)
history = model.fit(
X_train, y_train,
epochs=5,
validation_data=(X_test, y_test)
)
loss, accuracy = model.evaluate(X_test, y_test)
print(“Test Accuracy:”, accuracy)
CNN on MNIST with Training Curves
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()
X_train = X_train.reshape(-1, 28, 28, 1) / 255.0
X_test = X_test.reshape(-1, 28, 28, 1) / 255.0
model = Sequential([
Conv2D(32, (3,3), activation=”relu”, input_shape=(28,28,1)),
MaxPooling2D(),
Conv2D(64, (3,3), activation=”relu”),
MaxPooling2D(),
Flatten(),
Dense(64, activation=”relu”),
Dense(10, activation=”softmax”)
])
model.compile(
optimizer=”adam”,
loss=”sparse_categorical_crossentropy”,
metrics=[“accuracy”]
)
history = model.fit(
X_train, y_train,
epochs=10,
validation_data=(X_test, y_test)
)
loss, accuracy = model.evaluate(X_test, y_test)
print(“Test Accuracy:”, accuracy)
plt.plot(history.history[“accuracy”])
plt.plot(history.history[“val_accuracy”])
plt.xlabel(“Epoch”)
plt.ylabel(“Accuracy”)
plt.legend([“Train”, “Test”])
plt.show()
Regularization Comparison on Fashion-MNIST
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
from tensorflow.keras.regularizers import l1, l2
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()
X_train = X_train.reshape(-1, 28, 28, 1) / 255.0
X_test = X_test.reshape(-1, 28, 28, 1) / 255.0
def create_model(reg=None, dropout=False):
model = Sequential([
Conv2D(32, (3,3), activation=”relu”, padding=”same”, input_shape=(28,28,1)),
Conv2D(32, (3,3), activation=”relu”), MaxPooling2D(),
Conv2D(64, (3,3), activation=”relu”),
Conv2D(64, (3,3), activation=”relu”), MaxPooling2D(),
Flatten(),
Dense(128, activation=”relu”, kernel_regularizer=reg)])
if dropout: model.add(Dropout(0.5))
model.add(Dense(10, activation=”softmax”))
model.compile(
optimizer=”adam”,
loss=”sparse_categorical_crossentropy”,
metrics=[“accuracy”])
return model
models = { “Base”: create_model(),
“L1”: create_model(l1(0.001)),
“L2”: create_model(l2(0.001)),
“Dropout”: create_model(dropout=True),
“L2 + Dropout”: create_model(l2(0.001), dropout=True)}
for name, model in models.items():
print(“\n”, name)
history = model.fit(X_train, y_train,
epochs=5, batch_size=28,
verbose=0)
train_acc = model.evaluate(X_train, y_train, verbose=0)[1]
test_acc = model.evaluate(X_test, y_test, verbose=0)[1]
print(“Training Accuracy:”, train_acc)
print(“Test Accuracy:”, test_acc)
Deep CNN Architecture Summary
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, Activation
from tensorflow.keras.layers import MaxPooling2D
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dense
img_size = (224,224,3)
num_classes = 10
filters = [16,32,64,128,256]
kernel_size = (3,3)
activation = “relu”
dense_neurons = 256
model = Sequential()
model.add(Conv2D(filters[0], kernel_size, input_shape=img_size))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(filters[1], kernel_size))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(filters[2], kernel_size))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(filters[3], kernel_size))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(filters[4], kernel_size))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Flatten())
model.add(Dense(dense_neurons, activation=activation))
model.add(Dense(num_classes, activation=”softmax”))
model.compile(
optimizer=”adam”,
loss=”categorical_crossentropy”,
metrics=[“accuracy”]
)
model.summary()
Simple RNN for Sequence Prediction
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import SimpleRNN, Dense
X = np.array([
[1,2,3,4,5],
[2,3,4,5,6],
[3,4,5,6,7],
[4,5,6,7,8],
[5,6,7,8,9]
], dtype=float)
y = np.array([6,7,8,9,10], dtype=float)
X = X.reshape((5, 5, 1))
model = Sequential([
SimpleRNN(32, activation=”relu”, input_shape=(5,1)),
Dense(1)
])
model.compile(
optimizer=’adam’,
loss=’mse’
)
model.fit(X, y, epochs=500, verbose=0)
mse = model.evaluate(X, y, verbose=0)
test = np.array([[6,7,8,9,10]], dtype=float)
test = test.reshape((1,5,1))
prediction = model.predict(test)
print(“Model Loss (MSE) :”, round(float(mse), 4))
print(“Input Sequence:”, [6,7,8,9,10])
print(“Raw Predicted Value :”, round(float(prediction[0][0]), 2))
print(“Predicted Next Value:”, round(float(prediction[0][0])))
LSTM for Monthly Milk Production Forecasting
import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
data = pd.read_csv(“monthly-milk-production-pounds.csv”)
milk = data[“Price”].dropna().values
maximum = milk.max()
milk = milk / maximum
X = []
y = []
for i in range(len(milk) – 5):
X.append(milk[i:i+5])
y.append(milk[i+5])
X = np.array(X)
y = np.array(y)
X = X.reshape(X.shape[0], 5, 1)
model = Sequential([
LSTM(32, input_shape=(5, 1)),
Dense(1)
])
model.compile(optimizer=”adam”, loss=”mse”)
model.fit(X, y, epochs=20, batch_size=8)
pred = model.predict(X[:1])
pred = pred[0][0] * maximum
print(“\n— Milk Production Prediction —“)
print(“Actual Production :”, y[0] * maximum)
print(“Predicted Production:”, pred)
Transfer Learning with ResNet50 on MNIST
import tensorflow as tf
from tensorflow.keras import layers, models, datasets
from tensorflow.keras.applications import ResNet50
from tensorflow.keras.utils import to_categorical
(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data()
x_train = x_train / 255.0
x_test = x_test / 255.0
x_train = tf.expand_dims(x_train, axis=-1)
x_test = tf.expand_dims(x_test, axis=-1)
x_train = tf.image.grayscale_to_rgb(x_train)
x_test = tf.image.grayscale_to_rgb(x_test)
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)
resnet_base = ResNet50(weights=”imagenet”,
include_top=False,
input_shape=(224, 224, 3))
resnet_base.trainable = False
model = models.Sequential([
layers.Input(shape=(28, 28, 3)),
layers.Resizing(224, 224),
resnet_base,
layers.GlobalAveragePooling2D(),
layers.Dense(256, activation=”relu”),
layers.Dropout(0.3),
layers.Dense(10, activation=”softmax”)])
model.compile(
optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
loss=”categorical_crossentropy”,
metrics=[“accuracy”])
model.summary()
print(“Starting training…”)
history = model.fit(x_train, y_train,
batch_size=64, epochs=3,
validation_data=(x_test, y_test))
test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=1)
print(f”Test Loss: {test_loss:.4f}”)
print(f”Test Accuracy: {test_accuracy:.4f}”)
AlexNet-Style CNN on MNIST
import tensorflow as tf
from tensorflow.keras import layers, models, datasets
from tensorflow.keras.utils import to_categorical
(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data()
x_train = x_train / 255.0
x_test = x_test / 255.0
x_train = tf.expand_dims(x_train, axis=-1)
x_test = tf.expand_dims(x_test, axis=-1)
x_train = tf.image.grayscale_to_rgb(x_train)
x_test = tf.image.grayscale_to_rgb(x_test)
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)
model = models.Sequential([
layers.Input(shape=(28, 28, 3)),
layers.Resizing(227, 227),
layers.Conv2D(filters=96, kernel_size=(11, 11), strides=(4, 4), activation=”relu”, padding=”same”),
layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2)),
layers.Conv2D(filters=256, kernel_size=(5, 5), activation=”relu”, padding=”same”),
layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2)),
layers.Conv2D(filters=384, kernel_size=(3, 3), activation=”relu”, padding=”same”),
layers.Conv2D(filters=384, kernel_size=(3, 3), activation=”relu”, padding=”same”),
layers.Conv2D(filters=256, kernel_size=(3, 3), activation=”relu”, padding=”same”),
layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2)), layers.Flatten(),
layers.Dense(4096, activation=”relu”), layers.Dropout(0.5),
layers.Dense(4096, activation=”relu”), layers.Dropout(0.5),
layers.Dense(10, activation=”softmax”)])
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
loss=”categorical_crossentropy”, metrics=[“accuracy”])
model.summary()
print(“Starting training…”)
history = model.fit(x_train, y_train,
batch_size=64, epochs=3,
validation_data=(x_test, y_test))
test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=1)
print(f”Test Loss: {test_loss:.4f}”)
print(f”Test Accuracy: {test_accuracy:.4f}”)
Sentiment Analysis on IMDB with SimpleRNN
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, SimpleRNN, Dense
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=10000)
x_train = pad_sequences(x_train, maxlen=200)
x_test = pad_sequences(x_test, maxlen=200)
model = Sequential([
Embedding(10000, 32),
SimpleRNN(32),
Dense(1, activation=’sigmoid’)
])
model.compile(
optimizer=’adam’,
loss=’binary_crossentropy’,
metrics=[‘accuracy’]
)
model.fit(
x_train, y_train,
epochs=5,
batch_size=64
)
loss, accuracy = model.evaluate(x_test, y_test)
print(“Test Accuracy:”, accuracy)
predictions = model.predict(x_test[:5])
print(“\nSample Predictions”)
for i in range(5):
prob = float(predictions[i][0])
actual = “Positive” if y_test[i] == 1 else “Negative”
predicted = “Positive” if prob >= 0.5 else “Negative”
confidence = prob if prob >= 0.5 else 1 – prob
print(“\nReview”, i + 1)
print(“Actual :”, actual)
print(“Predicted:”, predicted)
print(“Confidence:”, round(confidence, 2))
CIFAR-10 CNN with Data Augmentation
import tensorflow as tf
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
from tensorflow.keras.preprocessing.image import ImageDataGenerator
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
X_train = X_train.astype(“float32”) / 255.0
X_test = X_test.astype(“float32”) / 255.0
y_train = y_train.flatten()
y_test = y_test.flatten()
datagen = ImageDataGenerator(
rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
datagen.fit(X_train)
model = Sequential([
Conv2D(32, (3, 3), activation=’relu’, padding=’same’, input_shape=(32, 32, 3)),
MaxPooling2D((2, 2)),
Conv2D(64, (3, 3), activation=’relu’, padding=’same’),
MaxPooling2D((2, 2)),
Conv2D(128, (3, 3), activation=’relu’, padding=’same’),
MaxPooling2D((2, 2)),
Flatten(),
Dense(256, activation=’relu’),
Dropout(0.5),
Dense(10, activation=’softmax’)])
model.compile(
optimizer=’adam’,
loss=’sparse_categorical_crossentropy’,
metrics=[‘sparse_categorical_accuracy’])
history = model.fit(
datagen.flow(X_train, y_train, batch_size=28),
epochs=5,
validation_data=(X_test, y_test))
loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
print(“Test Accuracy:”, accuracy)
LSTM Temperature Forecasting on Delhi Climate Data
import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
train = pd.read_csv(“DailyDelhiClimateTrain.csv”)
test = pd.read_csv(“DailyDelhiClimateTest.csv”)
train = train[“meantemp”].values
test = test[“meantemp”].values
X_train = []
y_train = []
for i in range(len(train) – 5):
X_train.append(train[i:i+5])
y_train.append(train[i+5])
X_test = []
y_test = []
for i in range(len(test) – 5):
X_test.append(test[i:i+5])
y_test.append(test[i+5])
X_train = np.array(X_train)
y_train = np.array(y_train)
X_test = np.array(X_test)
y_test = np.array(y_test)
X_train = X_train.reshape(X_train.shape[0], 5, 1)
X_test = X_test.reshape(X_test.shape[0], 5, 1)
model = Sequential([
LSTM(32, input_shape=(5, 1)),
Dense(1)
])
model.compile(optimizer=”adam”, loss=”mse”)
model.fit(X_train, y_train, epochs=50, batch_size=32)
pred = model.predict(X_test[:1])
print(“\n— Result —“)
print(“Actual Temperature :”, y_test[0])
print(“Predicted Temperature:”, pred[0][0])