ELEC 395 - Week 6

MIDTERM EXAMINATION

Assessment of Weeks 1-5 Material

Written & Practical Components • 1-2 Hours

📋

Midterm Examination Overview

⚠️ Important Information

This is a comprehensive assessment of all material covered in Weeks 1-5 of ELEC 395. The midterm examination consists of both written and practical components designed to evaluate your understanding of artificial intelligence fundamentals, neural networks, PyTorch programming, and hardware integration with Jetson Nano and JetBot platforms.

📅

Date & Time

Week 6

During scheduled lab time

⏱️

Duration

1-2 Hours

Total examination time

📝

Format

Hybrid

Written + Practical

💯

Total Points

100

Written: 50 | Practical: 50

📚 Exam Coverage

The midterm examination will assess your knowledge and skills across the following areas:

Week 1: Python for hardware, Jetson Nano & Raspberry Pi, JetBot assembly and components
Week 2: Machine learning & AI fundamentals, gradient descent, activation functions
Week 3: PyTorch tensors, neural networks, training procedures, Fashion-MNIST
Week 4: Image datasets (MNIST, CIFAR-10), CNNs, image classification techniques
Week 5: PyTorch/TensorFlow implementations, practical deep learning applications

📖 Open/Closed Book Policy

To Be Determined: Your instructor will announce whether this exam is open-book or closed-book during the review session. Please check your course announcements for the final policy.

Suggested: Prepare as if it's closed-book, then you'll be ready for either format!

📖

Detailed Topics Covered

Below is a comprehensive breakdown of topics from Weeks 1-5 that will be assessed in the midterm examination:

Week 1

Python for Real Hardware - Jetson & Raspberry Pi

Key Topics:

Introduction to NVIDIA Jetson Nano Developer Kit specifications and capabilities
Raspberry Pi hardware architecture and comparison with Jetson
JetBot robot assembly process and component identification
Initial setup and configuration of Jetson Nano
Understanding hardware interfaces: GPIO, I2C, SPI, UART
Power management and thermal considerations
Basic Linux commands for embedded systems

Week 2

Fundamentals of Machine Learning and Artificial Intelligence

Key Topics:

Introduction to artificial intelligence and machine learning concepts
Supervised vs. unsupervised learning paradigms
Artificial Neural Networks (ANN) fundamentals and architecture
Gradient descent algorithm and optimization techniques
Activation functions: Sigmoid, ReLU, Tanh, and their properties
Forward propagation and backpropagation mechanics
Loss functions and cost calculation
Learning rate and its impact on training
Python implementation of basic neural network components

Week 3

Introduction to ANN, Deep Learning, CNN with PyTorch

Key Topics:

PyTorch framework fundamentals and tensor operations
Creating and manipulating tensors in PyTorch
Building neural networks using torch.nn module
Sequential and custom neural network architectures
Training neural networks: forward pass, loss calculation, backpropagation
Optimizers: SGD, Adam, RMSprop
Fashion-MNIST dataset loading and preprocessing
Data loaders and batch processing
Model evaluation and validation techniques
Transfer learning concepts and applications

Week 4

Data Representation and ML Datasets

Key Topics:

MNIST dataset structure and characteristics
CIFAR-10 dataset overview and complexity
Image representation as tensors
Data normalization and standardization techniques
Convolutional Neural Networks (CNN) architecture
Convolutional layers, pooling layers, and fully connected layers
Filters, kernels, and feature maps
Padding, stride, and receptive fields
Image classification pipeline with CNNs
Data augmentation techniques for improved generalization

Week 5

Hands-on Python Libraries - PyTorch & TensorFlow

Key Topics:

Comprehensive PyTorch programming and best practices
Introduction to TensorFlow framework
Comparison between PyTorch and TensorFlow
Building end-to-end deep learning pipelines
Model saving and loading procedures
GPU acceleration and CUDA integration
Practical implementation of neural networks for real-world tasks
Debugging and troubleshooting deep learning models
Performance optimization techniques

📝 Study Focus Areas

While all topics listed above may appear on the exam, pay special attention to:

Core Concepts: Gradient descent, backpropagation, activation functions
PyTorch Fundamentals: Tensor operations, building neural networks, training loops
CNN Architecture: Understanding convolution operations and layer functions
Practical Skills: Debugging code, interpreting results, dataset handling
Hardware Integration: Understanding Jetson Nano capabilities and limitations

📊

Exam Format & Structure

The midterm examination consists of two major components, each worth 50 points:

✍️ Part 1: Written Component (50 Points)

Duration: Approximately 45-60 minutes

Question Types:

Question Type	Number of Questions	Points Each	Total Points
Multiple Choice Questions (MCQ)	20	1.5	30
Short Answer Questions	4	3	12
Diagram/Concept Questions	2	4	8
Total Written Component	26	-	50

Written Component Details:

MCQs: Cover conceptual understanding, terminology, and theoretical foundations
Short Answers: Require brief explanations of concepts (3-5 sentences each)
Diagrams: May include drawing neural network architectures, CNN structures, or flowcharts
Topics Emphasis: Balanced coverage across all 5 weeks with heavier weight on Weeks 2-4

💻 Part 2: Practical/Coding Component (50 Points)

Duration: Approximately 45-60 minutes

Programming Tasks:

Task Type	Number of Problems	Points Each	Total Points
Code Completion/Debugging	2	8	16
Short Coding Problems	2	10	20
Mini-Project Implementation	1	14	14
Total Practical Component	5	-	50

Practical Component Details:

Code Completion: Fix errors in provided code or complete partially written functions
Short Problems: Write specific functions or small programs from scratch
Mini-Project: Implement a complete neural network training pipeline or CNN classifier
Environment: Jupyter Notebook or Python scripts on your laptop/lab computer
Allowed Resources: PyTorch documentation (if open-book), your own notes

⏰ Time Management Strategy

To succeed in the exam, allocate your time wisely:

First 5 minutes: Quickly read through entire exam to understand all questions
Written Section (45-60 min):
- MCQs: ~1-2 minutes each (30-40 minutes total)
- Short answers: ~3-4 minutes each (12-16 minutes)
- Diagrams: ~4-5 minutes each (8-10 minutes)
Practical Section (45-60 min):
- Code completion: ~6-8 minutes each
- Short problems: ~8-10 minutes each
- Mini-project: ~20-25 minutes
Final 5-10 minutes: Review answers and test your code

📚

Comprehensive Study Guide

This study guide provides key concepts, formulas, and important points from each week. Use this as a checklist for your review.

Week 1: Hardware Foundations

Essential Concepts to Master:

Jetson Nano Specifications:
- 128-core NVIDIA Maxwell GPU
- Quad-core ARM A57 CPU @ 1.43 GHz
- 4GB LPDDR4 RAM
- Power consumption: 5W (idle) to 10W (peak)
JetBot Components: Understand the function of motors, camera, battery, motor driver, OLED display
GPIO Basics: General Purpose Input/Output pins for sensor/actuator interface
Key Commands:
- jetson_release - Check Jetson system information
- sudo jetson_clocks - Maximize performance
- tegrastats - Monitor system resources
Setup Process: SD card flashing, initial boot, network configuration

Week 2: Machine Learning Fundamentals

Critical Concepts & Formulas:

1. Gradient Descent:

θ = θ - α × ∇J(θ)

Where:
  θ = model parameters (weights)
  α = learning rate
  ∇J(θ) = gradient of cost function

2. Activation Functions:

# Sigmoid
σ(x) = 1 / (1 + e^(-x))
Range: (0, 1)
Use case: Binary classification output layer

# ReLU (Rectified Linear Unit)
ReLU(x) = max(0, x)
Range: [0, ∞)
Use case: Hidden layers (most common)

# Tanh (Hyperbolic Tangent)
tanh(x) = (e^x - e^(-x)) / (e^x + e^(-x))
Range: (-1, 1)
Use case: Hidden layers when centered data is needed

3. Loss Functions:

# Mean Squared Error (MSE) - Regression
MSE = (1/n) × Σ(y_true - y_pred)²

# Binary Cross-Entropy - Binary Classification
BCE = -(1/n) × Σ[y×log(ŷ) + (1-y)×log(1-ŷ)]

# Categorical Cross-Entropy - Multi-class Classification
CCE = -(1/n) × Σ Σ y_ic × log(ŷ_ic)

4. Key Terminology:

Epoch: One complete pass through entire training dataset
Batch: Subset of training data processed together
Learning Rate: Step size for parameter updates (typical: 0.001 - 0.1)
Overfitting: Model memorizes training data, poor generalization
Underfitting: Model too simple, poor performance on both training and test data

Week 3: PyTorch & Neural Networks

PyTorch Essentials:

1. Tensor Operations:

import torch

# Creating tensors
x = torch.tensor([1, 2, 3])
y = torch.zeros(3, 3)
z = torch.randn(2, 3)  # Random normal distribution

# Common operations
a = x.reshape(3, 1)     # Reshape
b = x.view(1, 3)        # View (similar to reshape)
c = torch.cat([x, y])   # Concatenate
d = x.unsqueeze(0)      # Add dimension

# Moving to GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = x.to(device)

2. Building Neural Networks:

import torch.nn as nn

# Method 1: Sequential
model = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),
    nn.Linear(256, 10),
    nn.Softmax(dim=1)
)

# Method 2: Custom Class
class NeuralNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 256)
        self.fc2 = nn.Linear(256, 10)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

3. Training Loop Pattern:

import torch.optim as optim

# Setup
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Training loop
for epoch in range(num_epochs):
    for images, labels in train_loader:
        # Forward pass
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # Backward pass
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    print(f'Epoch {epoch+1}, Loss: {loss.item():.4f}')

4. Important Concepts:

optimizer.zero_grad(): Must clear gradients before each backward pass
.backward(): Computes gradients via backpropagation
optimizer.step(): Updates model parameters using computed gradients
model.train() vs model.eval(): Different behavior for dropout/batch normalization

Week 4: CNNs & Image Datasets

Convolutional Neural Networks:

1. CNN Architecture Components:

Convolutional Layer: Applies filters to extract features
nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)
Pooling Layer: Reduces spatial dimensions
nn.MaxPool2d(kernel_size, stride) nn.AvgPool2d(kernel_size, stride)
Fully Connected Layer: Final classification layers
nn.Linear(in_features, out_features)

2. Output Size Calculation:

Output Size = ((Input Size - Kernel Size + 2×Padding) / Stride) + 1

Example:
Input: 28×28 image
Kernel: 3×3
Padding: 1
Stride: 1

Output = ((28 - 3 + 2×1) / 1) + 1 = 28×28

3. Common Datasets:

MNIST: 70,000 handwritten digits (28×28 grayscale), 10 classes
Fashion-MNIST: 70,000 fashion items (28×28 grayscale), 10 classes
CIFAR-10: 60,000 color images (32×32 RGB), 10 classes

4. Data Preprocessing:

from torchvision import transforms

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))  # Mean, Std
])

# Data augmentation
train_transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomRotation(10),
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

Week 5: Advanced PyTorch & TensorFlow

Advanced Techniques:

1. Model Saving & Loading:

# Save model
torch.save(model.state_dict(), 'model.pth')

# Load model
model = MyModel()
model.load_state_dict(torch.load('model.pth'))
model.eval()

2. GPU Utilization:

# Check GPU availability
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

# Move model and data to GPU
model = model.to(device)
inputs = inputs.to(device)
labels = labels.to(device)

3. Common Debugging Tips:

Shape Mismatches: Use .shape to debug tensor dimensions
NaN Loss: Check for exploding gradients, reduce learning rate
GPU Out of Memory: Reduce batch size or model complexity
No Learning: Verify optimizer is updating parameters, check learning rate

4. PyTorch vs TensorFlow:

Aspect	PyTorch	TensorFlow
Computation	Dynamic (define-by-run)	Static (define-then-run)
Debugging	Easier (Pythonic)	More complex
Production	Growing support	Mature ecosystem
Community	Research-focused	Industry-focused

📥 Download Complete Study Guide

Get the comprehensive PDF study guide with all formulas, code examples, and quick reference materials.

❓

Sample Written Questions

Practice with these sample multiple-choice questions covering all weeks. Click on your answer to check if it's correct.

Question 1: Hardware Specifications (Week 1)

What is the GPU architecture used in the NVIDIA Jetson Nano Developer Kit?

A) Pascal architecture with 256 cores
B) Maxwell architecture with 128 cores
C) Turing architecture with 64 cores
D) Volta architecture with 192 cores

Question 2: Activation Functions (Week 2)

Which activation function has an output range of (0, 1) and is commonly used in the output layer for binary classification?

A) ReLU (Rectified Linear Unit)
B) Sigmoid
C) Tanh (Hyperbolic Tangent)
D) Softmax

Question 3: Gradient Descent (Week 2)

In the gradient descent update rule θ = θ - α × ∇J(θ), what does α represent?

A) The gradient of the cost function
B) The learning rate
C) The momentum parameter
D) The regularization coefficient

Question 4: PyTorch Tensors (Week 3)

What is the primary difference between tensor.reshape() and tensor.view() in PyTorch?

A) reshape() is faster than view()
B) view() can only be used on contiguous tensors
C) reshape() returns a copy if needed, view() requires contiguous memory
D) There is no difference, they are identical

Question 5: Training Loop (Week 3)

Why is optimizer.zero_grad() necessary in the PyTorch training loop?

A) To initialize the optimizer parameters
B) To clear accumulated gradients from the previous iteration
C) To reset the model weights to zero
D) To enable gradient computation

Question 6: CNN Components (Week 4)

What is the primary purpose of a pooling layer in a Convolutional Neural Network?

A) To increase the spatial dimensions of feature maps
B) To reduce spatial dimensions and extract dominant features
C) To apply non-linear transformations
D) To normalize the activations

Question 7: Output Size Calculation (Week 4)

Given an input image of size 32×32, a convolutional layer with kernel size 5×5, stride 1, and padding 2, what is the output size?

A) 28×28
C) 30×30
B) 32×32
D) 34×34

Question 8: Fashion-MNIST Dataset (Week 3)

How many classes are in the Fashion-MNIST dataset?

A) 10 classes
B) 26 classes
C) 100 classes
D) 1000 classes

Question 9: Overfitting (Week 2)

Which of the following is a symptom of overfitting in a neural network?

A) High training error and high validation error
B) Low training error but high validation error
C) High training error but low validation error
D) Low training error and low validation error

Question 10: Loss Functions (Week 2)

Which loss function is most appropriate for a multi-class classification problem with mutually exclusive classes?

A) Mean Squared Error (MSE)
B) Binary Cross-Entropy
C) Categorical Cross-Entropy
D) Hinge Loss

Question 11: CIFAR-10 Dataset (Week 4)

What are the dimensions of each image in the CIFAR-10 dataset?

A) 28×28 grayscale
B) 32×32 RGB color
C) 64×64 RGB color
D) 224×224 RGB color

Question 12: Backpropagation (Week 2)

What is the primary purpose of the backpropagation algorithm?

A) To make forward predictions through the network
B) To compute gradients of the loss with respect to network parameters
C) To normalize the input data
D) To initialize network weights

Question 13: Model Evaluation (Week 3)

What is the purpose of calling model.eval() in PyTorch?

A) To start the training process
B) To set the model to evaluation mode, disabling dropout and batch normalization updates
C) To evaluate the loss function
D) To compute model accuracy

Question 14: Data Augmentation (Week 4)

Which of the following is NOT a common data augmentation technique for image data?

A) Random horizontal flipping
B) Random rotation
C) Random cropping
D) Feature scaling

Question 15: GPU Computing (Week 5)

Which PyTorch command checks if CUDA (GPU) is available?

A) torch.cuda.is_available()
B) torch.has_cuda()
C) torch.gpu.check()
D) torch.device.cuda()

📝 Additional Question Types

The actual exam will also include:

Short Answer Questions: Explain concepts in 3-5 sentences (e.g., "Explain why ReLU is preferred over Sigmoid in hidden layers")
Diagram Questions: Draw and label neural network architectures, CNN structures, or training flowcharts
Calculation Problems: Compute output sizes, parameter counts, or gradient descent steps
Code Reading: Identify errors or explain what given code snippets do

💻

Sample Coding Problems

Practice these coding problems to prepare for the practical component of the exam. Solutions are password-protected.

Problem 1: Tensor Operations (Easy) - 8 Points

Task: Complete the following function that creates a 3×3 tensor filled with random values from a normal distribution, then computes its transpose and returns both tensors.

import torch

def create_and_transpose():
    """
    Create a 3x3 tensor with random normal values
    and return both the original and transposed tensor.
    
    Returns:
        tuple: (original_tensor, transposed_tensor)
    """
    # YOUR CODE HERE
    pass

# Test your function
original, transposed = create_and_transpose()
print("Original tensor:")
print(original)
print("\nTransposed tensor:")
print(transposed)

Expected Skills: Tensor creation, random initialization, transpose operation

Problem 2: Activation Function Implementation (Easy) - 8 Points

Task: Implement the sigmoid activation function from scratch using NumPy or PyTorch. Do not use built-in activation functions.

import torch
import math

def sigmoid(x):
    """
    Implement the sigmoid activation function.
    
    Args:
        x: Input tensor
    
    Returns:
        Tensor with sigmoid applied element-wise
    """
    # YOUR CODE HERE
    # Formula: σ(x) = 1 / (1 + e^(-x))
    pass

# Test your function
x = torch.tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
result = sigmoid(x)
print(f"Input: {x}")
print(f"Sigmoid output: {result}")
print(f"Expected: [0.1192, 0.2689, 0.5000, 0.7311, 0.8808]")

Expected Skills: Mathematical implementation, element-wise operations

Problem 3: Build a Simple Neural Network (Medium) - 10 Points

Task: Create a simple 2-layer neural network for binary classification using PyTorch. The network should have:

Input layer: 10 features
Hidden layer: 5 neurons with ReLU activation
Output layer: 1 neuron with Sigmoid activation

import torch
import torch.nn as nn

class BinaryClassifier(nn.Module):
    def __init__(self):
        super(BinaryClassifier, self).__init__()
        # YOUR CODE HERE
        # Define the layers
        pass
    
    def forward(self, x):
        # YOUR CODE HERE
        # Implement forward pass
        pass

# Test your model
model = BinaryClassifier()
test_input = torch.randn(1, 10)  # Batch of 1, 10 features
output = model(test_input)
print(f"Output shape: {output.shape}")
print(f"Output value (should be between 0 and 1): {output.item():.4f}")

Expected Skills: Neural network architecture, layer definition, forward pass

Problem 4: Training Loop Implementation (Medium) - 10 Points

Task: Complete the training loop for a neural network. You need to fill in the missing steps.

import torch
import torch.nn as nn
import torch.optim as optim

# Assume model, train_loader are already defined
def train_one_epoch(model, train_loader, criterion, optimizer):
    """
    Train the model for one epoch.
    
    Args:
        model: Neural network model
        train_loader: DataLoader with training data
        criterion: Loss function
        optimizer: Optimizer
    
    Returns:
        float: Average loss for the epoch
    """
    model.train()
    total_loss = 0
    
    for batch_idx, (data, target) in enumerate(train_loader):
        # Step 1: Clear gradients
        # YOUR CODE HERE
        
        # Step 2: Forward pass
        # YOUR CODE HERE
        
        # Step 3: Compute loss
        # YOUR CODE HERE
        
        # Step 4: Backward pass
        # YOUR CODE HERE
        
        # Step 5: Update parameters
        # YOUR CODE HERE
        
        total_loss += loss.item()
    
    avg_loss = total_loss / len(train_loader)
    return avg_loss

Expected Skills: Training loop structure, gradient handling, loss computation

Problem 5: Mini-Project - MNIST Digit Classifier (Hard) - 14 Points

Task: Build a complete convolutional neural network to classify MNIST digits. Your solution should include:

CNN architecture with at least 2 convolutional layers
Proper data loading and preprocessing
Training loop for 3 epochs
Evaluation on test set

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# 1. Define your CNN architecture
class MNISTClassifier(nn.Module):
    def __init__(self):
        super(MNISTClassifier, self).__init__()
        # YOUR CODE HERE
        # Should include:
        # - At least 2 Conv2d layers
        # - Pooling layers
        # - Fully connected layers
        pass
    
    def forward(self, x):
        # YOUR CODE HERE
        pass

# 2. Data loading and preprocessing
def load_data():
    # YOUR CODE HERE
    # Load MNIST dataset with appropriate transforms
    pass

# 3. Training function
def train_model(model, train_loader, criterion, optimizer, epochs=3):
    # YOUR CODE HERE
    pass

# 4. Evaluation function
def evaluate_model(model, test_loader):
    # YOUR CODE HERE
    # Should return accuracy
    pass

# Main execution
if __name__ == "__main__":
    model = MNISTClassifier()
    train_loader, test_loader = load_data()
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    train_model(model, train_loader, criterion, optimizer)
    accuracy = evaluate_model(model, test_loader)
    print(f"Test Accuracy: {accuracy:.2f}%")

Expected Skills: Complete ML pipeline, CNN architecture, data handling, training and evaluation

Target: Achieve >95% accuracy on MNIST test set

⏰ Time Management for Practical Section

Easy Problems (8 pts each): Allocate 6-8 minutes per problem
Medium Problems (10 pts each): Allocate 8-10 minutes per problem
Hard Mini-Project (14 pts): Allocate 20-25 minutes
Testing: Always leave 5 minutes to test your code before submission

⚖️

Exam Policies & Guidelines

🚫 Academic Integrity Policy

Zero Tolerance: The following actions are strictly prohibited and will result in immediate failure of the exam and potential disciplinary action:

Copying answers from other students or external sources
Communicating with other students during the exam (verbally, digitally, or by any means)
Using unauthorized materials or resources
Accessing internet resources during closed-book sections (if applicable)
Taking pictures or screenshots of exam questions
Sharing exam content with students who haven't taken it yet
Using AI assistants (ChatGPT, Claude, etc.) to generate answers

Remember: Academic integrity is fundamental to your education. Violations will be reported to university administration.

📋 What to Bring

Required Items:

✓ Valid student ID card
✓ Writing materials (pens, pencils, erasers)
✓ Laptop with fully charged battery (for practical section)
✓ Power adapter/charger
✓ Calculator (if permitted by instructor)

Conditionally Allowed (Check with instructor):

? Personal notes (if open-book format)
? Textbooks or printed course materials
? PyTorch documentation (printed or digital)

Strictly Prohibited:

✗ Mobile phones (must be turned off and stored away)
✗ Smart watches or fitness trackers
✗ Headphones or earbuds
✗ Tablets (unless specifically approved as laptop alternative)
✗ Any communication devices

🖥️ Software & Environment Setup

Before the Exam: Ensure your laptop has the following installed and working:

Python 3.7+ with pip package manager
PyTorch (latest stable version)
Jupyter Notebook or JupyterLab
Essential Libraries: NumPy, Matplotlib, torchvision
Code Editor/IDE: VS Code, PyCharm, or similar

Test Your Setup:

import torch
import torchvision
import numpy as np
import matplotlib.pyplot as plt

print(f"PyTorch version: {torch.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}")
print(f"NumPy version: {np.__version__}")
print("✓ All packages imported successfully!")

Note: Internet access may be disabled during the exam. Ensure all packages are pre-installed.

⏰ Exam Day Procedures

Arrival & Check-in:

Arrive 15 minutes early for setup and check-in
Present valid student ID for verification
Find your assigned seat (seating chart will be posted)
Set up laptop and test environment before exam starts
Store all unauthorized items (phones, bags) in designated area

During the Exam:

Raise your hand if you need clarification (ask quietly at your seat)
No bathroom breaks during first 30 minutes or last 15 minutes
If technical issues occur, immediately notify instructor
Work quietly and do not disturb other students
Save your work frequently during practical section

Submission:

Submit written component when finished or when time expires
For coding: Upload to designated LMS/server or USB collection
Ensure all files are named correctly: Midterm_[LastName]_[StudentID]
Wait for confirmation from instructor before leaving

⏱️ Late Arrival & Special Circumstances

Late Arrival: Students arriving >15 minutes late may not be admitted
Medical Emergencies: Contact instructor immediately with documentation
Technical Failures: Backup computers available on first-come basis
Accommodation: Students with approved accommodations should notify instructor 48 hours in advance
Make-up Exam: Only granted for documented emergencies (medical, family, university-approved)

📊 Grading & Results

Grade Distribution:

Component	Points	Percentage
Written Section	50	50%
Practical Section	50	50%
Total	100	100%

Timeline:

Preliminary scores: Within 5-7 business days
Final scores after review: Within 10 business days
Grade appeals: Must be submitted within 3 days of score release

Midterm Weight in Final Grade: Check your course syllabus (typically 20-30%)

💡

Exam Preparation Tips

📅 One Week Before Exam

Create a study schedule covering all 5 weeks of material
Review all laboratory reports and experiment results
Re-watch key Udacity video tutorials on challenging topics
Practice coding without looking at solutions first
Form study groups to discuss concepts and quiz each other
Identify weak areas and allocate extra study time accordingly
Ensure your laptop environment is properly configured

📘 2-3 Days Before Exam

Focus on understanding core concepts rather than memorization
Practice the sample questions provided in this page multiple times
Review all code from previous labs - understand every line
Create summary sheets with key formulas and concepts
Practice writing code from scratch without IDE autocomplete
Time yourself on practice problems to improve speed
Get adequate sleep - your brain needs rest to consolidate learning

🌙 Night Before Exam

Do a final quick review of key concepts (don't cram new material)
Test your laptop setup one more time
Charge your laptop fully + bring power adapter
Pack all required materials and ID
Set multiple alarms to wake up on time
Avoid all-night studying - sleep is crucial for performance
Relax and visualize yourself succeeding on the exam

📚 Effective Study Strategies

1. Active Learning Techniques:

Teach Others: Explain concepts to study partners - teaching reinforces understanding
Practice Retrieval: Quiz yourself without looking at notes first
Spaced Repetition: Review material multiple times over several days
Interleaved Practice: Mix different topics rather than blocking by week

2. For Conceptual Understanding:

Draw diagrams of neural network architectures from memory
Explain WHY algorithms work, not just HOW they work
Connect concepts across weeks (e.g., how gradient descent relates to PyTorch training)
Create concept maps showing relationships between topics

3. For Coding Proficiency:

Type out code examples from scratch rather than copy-paste
Deliberately break code and practice debugging
Implement algorithms in multiple ways
Practice reading and understanding others' code
Challenge yourself with variations of practice problems

🚫 Common Mistakes to Avoid

Don't: Passively re-read notes without testing yourself
Don't: Focus only on memorizing code without understanding logic
Don't: Neglect earlier weeks thinking they're less important
Don't: Study only theoretical concepts or only coding - balance both
Don't: Wait until the last minute to test your laptop setup
Don't: Stay up all night cramming - sleep deprivation hurts performance
Don't: Ignore practice problems because they seem too hard

⚡ During Exam Strategies

Time Management:

Read through entire exam first (5 minutes)
Answer easier questions first to build confidence
Mark difficult questions and return to them later
Keep track of time - don't spend too long on any single question
Save 10 minutes at the end for review

Written Section Tactics:

Read questions carefully - underline key terms
For MCQs: Eliminate obviously wrong answers first
For short answers: Organize thoughts before writing
Use technical terminology correctly
If unsure, provide your best educated guess rather than leaving blank

Practical Section Tactics:

Read problem requirements thoroughly before coding
Plan your approach - write pseudocode if helpful
Test incrementally - don't wait until the end
Use print statements to debug
Comment your code clearly
If stuck, move on and return later
Partial credit is available - submit something even if incomplete

📎

Additional Resources

🔗 Quick Links to Previous Week Materials

📚 Recommended Study Materials

Udacity Video Tutorials (Review These):

Gradient Descent: Introduction to Neural Networks - Gradient Descent
PyTorch Basics: Deep Learning PyTorch - Introduction
CNNs: Convolutional Neural Networks

Official Documentation:

Additional Learning Resources:

📥 Downloadable Materials

Access these helpful resources for your exam preparation:

🆘 Getting Help Before the Exam

Office Hours: Attend instructor office hours for clarification on confusing topics
Teaching Assistants: TAs are available for review sessions and questions
Study Groups: Form or join study groups with classmates
Course Forum: Post questions on the course discussion board
Email Instructor: For urgent questions or special accommodations

Pre-Exam Review Session: Check course announcements for a scheduled review session before the midterm. This is your opportunity to ask any last-minute questions!

💪 Final Encouragement

You've worked hard through the first five weeks of this course, building hands-on skills with neural networks, PyTorch, and embedded AI systems. The midterm examination is an opportunity to demonstrate what you've learned and identify areas for continued growth.

Remember:

The exam tests understanding, not just memorization
Partial credit is awarded for showing your thought process
It's okay to not know everything - focus on what you do know
Your preparation and effort matter more than perfection
This is one assessment of many - learning is a continuous journey

You've got this! Good luck! 🚀

Midterm Examination Overview

⚠️ Important Information

Date & Time

Duration

Format

Total Points

📚 Exam Coverage

📖 Open/Closed Book Policy

Detailed Topics Covered

Python for Real Hardware - Jetson & Raspberry Pi

Fundamentals of Machine Learning and Artificial Intelligence

Introduction to ANN, Deep Learning, CNN with PyTorch

Data Representation and ML Datasets

Hands-on Python Libraries - PyTorch & TensorFlow

📝 Study Focus Areas

Exam Format & Structure

✍️ Part 1: Written Component (50 Points)

💻 Part 2: Practical/Coding Component (50 Points)

⏰ Time Management Strategy

Comprehensive Study Guide

Week 1: Hardware Foundations

Week 2: Machine Learning Fundamentals

Week 3: PyTorch & Neural Networks

Week 4: CNNs & Image Datasets

Week 5: Advanced PyTorch & TensorFlow

📥 Download Complete Study Guide

Sample Written Questions

Question 1: Hardware Specifications (Week 1)

Question 2: Activation Functions (Week 2)

Question 3: Gradient Descent (Week 2)

Question 4: PyTorch Tensors (Week 3)

Question 5: Training Loop (Week 3)

Question 6: CNN Components (Week 4)

Question 7: Output Size Calculation (Week 4)

Question 8: Fashion-MNIST Dataset (Week 3)

Question 9: Overfitting (Week 2)

Question 10: Loss Functions (Week 2)

Question 11: CIFAR-10 Dataset (Week 4)

Question 12: Backpropagation (Week 2)

Question 13: Model Evaluation (Week 3)

Question 14: Data Augmentation (Week 4)

Question 15: GPU Computing (Week 5)

📝 Additional Question Types

Sample Coding Problems

Problem 1: Tensor Operations (Easy) - 8 Points

Problem 2: Activation Function Implementation (Easy) - 8 Points

Problem 3: Build a Simple Neural Network (Medium) - 10 Points

Problem 4: Training Loop Implementation (Medium) - 10 Points

Problem 5: Mini-Project - MNIST Digit Classifier (Hard) - 14 Points

⏰ Time Management for Practical Section

Exam Policies & Guidelines

🚫 Academic Integrity Policy

📋 What to Bring

🖥️ Software & Environment Setup

⏰ Exam Day Procedures

⏱️ Late Arrival & Special Circumstances

📊 Grading & Results

Exam Preparation Tips

📅 One Week Before Exam

📘 2-3 Days Before Exam

🌙 Night Before Exam

📚 Effective Study Strategies

🚫 Common Mistakes to Avoid

⚡ During Exam Strategies

Exam Readiness Checklist

📚 Content Mastery

💻 Practical Skills

📝 Exam Preparation

🎒 Logistics & Materials

😌 Mental & Physical Preparation

Additional Resources

🔗 Quick Links to Previous Week Materials

📚 Recommended Study Materials

📥 Downloadable Materials

🆘 Getting Help Before the Exam

💪 Final Encouragement