Neural network architecture in ML Python

Introduction

A neural network architecture is like a blueprint for how a computer learns from data. It shows how layers and neurons connect to solve problems like recognizing pictures or understanding speech.

When you want a computer to recognize handwritten numbers.

When building a system that understands spoken words.

When predicting house prices based on features like size and location.

When classifying emails as spam or not spam.

When creating a model to recommend movies based on your past choices.

Syntax

ML Python

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
    Dense(units=64, activation='relu', input_shape=(input_size,)),
    Dense(units=10, activation='softmax')
])

Sequential means layers are stacked one after another.

Dense layers are fully connected layers where each neuron connects to all neurons in the next layer.

Examples

A simple network for binary classification with 20 input features, one hidden layer with 32 neurons, and one output neuron.

ML Python

model = Sequential([
    Dense(32, activation='relu', input_shape=(20,)),
    Dense(1, activation='sigmoid')
])

A deeper network with two hidden layers for classifying into 10 categories.

ML Python

model = Sequential([
    Dense(128, activation='relu', input_shape=(100,)),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

Sample Model

This program creates a small neural network to classify data into 3 categories. It trains on random data and shows the training accuracy and prediction probabilities for a new sample.

ML Python

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

# Create dummy data: 100 samples, 20 features
X = np.random.random((100, 20))
# Create dummy labels for 3 classes
y = np.random.randint(3, size=(100,))
y_cat = to_categorical(y, 3)

# Build a simple neural network
model = Sequential([
    Dense(16, activation='relu', input_shape=(20,)),
    Dense(3, activation='softmax')
])

# Compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Train the model
history = model.fit(X, y_cat, epochs=5, batch_size=10, verbose=0)

# Print training accuracy after last epoch
print(f"Training accuracy after 5 epochs: {history.history['accuracy'][-1]:.4f}")

# Make a prediction on a new sample
new_sample = np.random.random((1, 20))
prediction = model.predict(new_sample)
print(f"Prediction probabilities: {prediction[0]}")

Important Notes

Input shape must match the number of features in your data.

Activation functions like 'relu' help the network learn complex patterns.

Output layer activation depends on the task: 'softmax' for multi-class, 'sigmoid' for binary.

Summary

Neural network architecture defines how layers and neurons connect to learn from data.

Use Sequential models to stack layers simply.

Choose layer sizes and activations based on your problem type.

Practice

1. What does the architecture of a neural network mainly describe?

easy

A. The type of keyboard used to code the network

B. How layers and neurons are connected to learn from data

C. The speed of the computer running the network

D. The color of the network's interface

Solution

1. Step 1: Understand the role of architecture in neural networks

   The architecture defines the structure, including layers and neuron connections, which determines how the network learns.

2. Step 2: Eliminate unrelated options

   Options about color, speed, or keyboard do not relate to network design or learning.

3. Final Answer:

   How layers and neurons are connected to learn from data -> Option B

4. Quick Check:

   Neural network architecture = connections and layers [OK]

Hint: Think about what controls learning structure [OK]

Common Mistakes:

• Confusing hardware with architecture
• Thinking architecture is about UI design

2. Which of the following is the correct way to start a simple Sequential model in Python using Keras?

easy

A. model = Sequential()

B. model = sequence()

C. model = Sequential[]

D. model = Sequential{}

Solution

1. Step 1: Recall the correct syntax for creating a Sequential model

   In Keras, the Sequential model is created by calling Sequential() with parentheses.

2. Step 2: Identify incorrect syntax

   Using lowercase, square brackets, or curly braces is invalid for this class instantiation.

3. Final Answer:

   model = Sequential() -> Option A

4. Quick Check:

   Use parentheses to create Sequential model [OK]

Hint: Remember classes need parentheses to create instances [OK]

Common Mistakes:

• Using square or curly brackets
• Using lowercase 'sequence' instead of 'Sequential'

3. Given this code snippet, what will be the output shape of the model's last layer?

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential()
model.add(Dense(10, input_shape=(5,), activation='relu'))
model.add(Dense(3, activation='softmax'))
print(model.output_shape)

medium

A. (None, 3)

B. (5, 10)

C. (None, 10)

D. (3, 5)

Solution

1. Step 1: Understand the model layers and their output shapes

   The first Dense layer outputs shape (None, 10) because input is (5,) and units=10. The second Dense layer outputs (None, 3) because it has 3 units.

2. Step 2: Identify the final output shape

   The model's output shape is the output of the last layer, which is (None, 3). None means batch size is flexible.

3. Final Answer:

   (None, 3) -> Option A

4. Quick Check:

   Last Dense units = output shape [OK]

Hint: Output shape matches last layer units [OK]

Common Mistakes:

• Confusing input shape with output shape
• Ignoring batch size dimension

4. Identify the error in this neural network code snippet:

model = Sequential()
model.add(Dense(32, activation='relu'))
model.add(Dense(1))
model.compile(optimizer='adam', loss='categorical_crossentropy')

medium

A. Activation function 'relu' is invalid

B. Missing input_shape in first Dense layer

C. Loss function 'categorical_crossentropy' is incorrect for single output

D. Optimizer 'adam' is not supported

Solution

1. Step 1: Check the output layer and loss function compatibility

   The output layer has 1 unit, likely for regression or binary classification. 'categorical_crossentropy' expects multiple classes, so it's incorrect here.

2. Step 2: Verify other parts

   Input shape can be set later or inferred, 'relu' is valid, and 'adam' optimizer is supported.

3. Final Answer:

   Loss function 'categorical_crossentropy' is incorrect for single output -> Option C

4. Quick Check:

   Loss must match output type [OK]

Hint: Match loss to output layer type [OK]

Common Mistakes:

• Assuming input_shape is always mandatory
• Confusing loss functions for output types

5. You want to build a neural network for a multi-class classification problem with 4 classes. Which architecture is best suited?

hard

A. Input layer -> Dense(1, softmax) -> Dense(4, relu)

B. Input layer -> Dense(4, relu) -> Dense(1, sigmoid)

C. Input layer -> Dense(10, sigmoid) -> Dense(4, relu)

D. Input layer -> Dense(16, relu) -> Dense(4, softmax)

Solution

1. Step 1: Understand output layer requirements for multi-class classification

   For 4 classes, output layer should have 4 units with softmax activation to output class probabilities.

2. Step 2: Check each option's output layer and activations

   Input layer -> Dense(16, relu) -> Dense(4, softmax) ends with Dense(4, softmax), which is correct. Others have wrong units or activations for output.

3. Final Answer:

   Input layer -> Dense(16, relu) -> Dense(4, softmax) -> Option D

4. Quick Check:

   Output units = number of classes, softmax for multi-class [OK]

Hint: Output units = classes, use softmax for multi-class [OK]

Common Mistakes:

• Using sigmoid for multi-class output
• Wrong number of output units
• Misplacing activation functions