Welcome to Programming Homework Help, where we specialize in providing expert assistance with machine learning assignments. Our dedicated team of professionals is here to ensure you excel in your studies by offering comprehensive support and high-quality sample assignments. Below, we present a couple of advanced machine learning questions along with their solutions, showcasing the depth and quality of the help we provide.
Question 1: Implementing a Custom Neural Network from Scratch
Problem Statement:
Implement a simple feedforward neural network from scratch using Python and NumPy. The network should have one hidden layer with ReLU activation and an output layer with softmax activation. Train this network on a subset of the MNIST dataset (use 1000 samples for training and 200 samples for validation). Evaluate the network's performance in terms of accuracy on the validation set.
Solution:
import numpy as np
from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
# Fetch MNIST data
mnist = fetch_openml('mnist_784', version=1)
X, y = mnist["data"], mnist["target"].astype(np.int)
# Normalize data
X = X / 255.0
# One-hot encoding of labels
encoder = OneHotEncoder(sparse=False)
y_onehot = encoder.fit_transform(y.reshape(-1, 1))
# Split the data
X_train, X_val, y_train, y_val = train_test_split(X, y_onehot, train_size=1000, test_size=200, random_state=42)
# Define the neural network architecture
input_size = 784
hidden_size = 128
output_size = 10
# Initialize weights and biases
np.random.seed(42)
W1 = np.random.randn(input_size, hidden_size) * 0.01
b1 = np.zeros((1, hidden_size))
W2 = np.random.randn(hidden_size, output_size) * 0.01
b2 = np.zeros((1, output_size))
# Activation functions
def relu(Z):
return np.maximum(0, Z)
def softmax(Z):
expZ = np.exp(Z - np.max(Z, axis=1, keepdims=True))
return expZ / expZ.sum(axis=1, keepdims=True)
# Forward propagation
def forward_propagation(X):
Z1 = np.dot(X, W1) + b1
A1 = relu(Z1)
Z2 = np.dot(A1, W2) + b2
A2 = softmax(Z2)
return Z1, A1, Z2, A2
# Loss function
def compute_loss(A2, Y):
m = Y.shape[0]
log_probs = -np.log(A2[range(m), np.argmax(Y, axis=1)])
loss = np.sum(log_probs) / m
return loss
# Backward propagation
def backward_propagation(X, Y, Z1, A1, A2):
m = X.shape[0]
dZ2 = A2 - Y
dW2 = np.dot(A1.T, dZ2) / m
db2 = np.sum(dZ2, axis=0, keepdims=True) / m
dA1 = np.dot(dZ2, W2.T)
dZ1 = dA1 * (Z1 > 0)
dW1 = np.dot(X.T, dZ1) / m
db1 = np.sum(dZ1, axis=0, keepdims=True) / m
return dW1, db1, dW2, db2
# Training the model
learning_rate = 0.01
num_iterations = 1000
for i in range(num_iterations):
# Forward propagation
Z1, A1, Z2, A2 = forward_propagation(X_train)
# Compute loss
loss = compute_loss(A2, y_train)
# Backward propagation
dW1, db1, dW2, db2 = backward_propagation(X_train, y_train, Z1, A1, A2)
# Update parameters
W1 -= learning_rate * dW1
b1 -= learning_rate * db1
W2 -= learning_rate * dW2
b2 -= learning_rate * db2
if i % 100 == 0:
print(f"Iteration {i}, Loss: {loss:.4f}")
# Evaluate the model
def predict(X):
_, _, _, A2 = forward_propagation(X)
return np.argmax(A2, axis=1)
y_val_pred = predict(X_val)
y_val_true = np.argmax(y_val, axis=1)
accuracy = np.mean(y_val_pred == y_val_true)
print(f"Validation Accuracy: {accuracy:.4f}")
Question 2: Building a Decision Tree Classifier for Classification
Problem Statement:
Using the scikit-learn library, implement a Decision Tree classifier to classify the Iris dataset. Perform a hyperparameter tuning to find the optimal depth of the tree using cross-validation. Report the best depth and the corresponding accuracy.
Solution:
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score, GridSearchCV
import numpy as np
# Load Iris dataset
iris = load_iris()
X, y = iris.data, iris.target
# Define the model
tree = DecisionTreeClassifier(random_state=42)
# Define hyperparameters to tune
param_grid = {'max_depth': np.arange(1, 10)}
# Use GridSearchCV for hyperparameter tuning
grid_search = GridSearchCV(tree, param_grid, cv=5, scoring='accuracy')
grid_search.fit(X, y)
# Best parameters and corresponding score
best_depth = grid_search.best_params_['max_depth']
best_score = grid_search.best_score_
print(f"Best Depth: {best_depth}")
print(f"Best Accuracy: {best_score:.4f}")
# Train the model with the best depth
best_tree = DecisionTreeClassifier(max_depth=best_depth, random_state=42)
best_tree.fit(X, y)
# Evaluate the model
accuracy = cross_val_score(best_tree, X, y, cv=5, scoring='accuracy').mean()
print(f"Cross-Validation Accuracy: {accuracy:.4f}")
Summary
In these examples, we've shown how to implement a simple feedforward neural network from scratch using Python and NumPy, and how to build and tune a Decision Tree classifier using scikit-learn. These examples highlight key concepts and practical implementations, demonstrating the type of expertise and detailed assistance you can expect when you seek help with machine learning assignment from Programming Homework Help.
Our experts are proficient in tackling complex machine learning problems and can provide personalized support tailored to your specific needs. Whether you need help understanding theoretical concepts, writing code from scratch, or debugging your existing projects, we're here to assist you. Visit us at Programming Homework Help and let our experts guide you to success in your machine learning journey.
