Introduction to Artificial Neural Networks

The Foundation of Modern AI

We have reached the final frontier of this course. Until now, we've used "Classical" Machine Learning. Now, we introduce Artificial Neural Networks (ANNs)—the core technology that powers ChatGPT, self-driving cars, and advanced facial recognition.

Inspired by the biological neurons in our own brains, ANNs allow us to model incredibly complex nonlinear relationships. In this chapter, we'll build our first Multi-Layer Perceptron (MLP) using Keras and Tensorflow, setting the stage for your journey into the world of Deep Learning.

From Biological to Artificial Neurons

In our brains, neurons receive electrical signals through dendrites and fire a signal down an axon if the input exceeds a certain threshold. ANNs use the same concept: the Threshold Logic Unit (TLU).

A TLU takes numerical inputs, multiplies them by "Weights" (importance), adds a "Bias", and then uses a step function to output a result. In HR, think of a neuron that "fires" only when a candidate's combined experience and project portfolio score is high enough.

Logical Computations with Neurons

A single neuron can represent simple logic. We can build an **AND gate** (fires only if BOTH inputs are 1) or an **OR gate** (fires if EITHER is 1). By combining these simple units into layers, we can represent any logical decision-making process, no matter how complex the corporate policy.

Python

# Simple OR gate logic with a neurondef or_neuron(x1, x2):    return 1 if (1.0 * x1 + 1.0 * x2) >= 1.0 else 0 print(f"0 OR 0: {or_neuron(0, 0)}")print(f"1 OR 0: {or_neuron(1, 0)}")

The Multilayer Perceptron (MLP)

A Multilayer Perceptron (MLP) consists of one input layer, one or more "Hidden Layers", and one final output layer. It's the layers in the middle (the hidden layers) that allow the network to learn complex non-linear patterns that simple algorithms miss.

Every layer (except the output) includes a Bias Neuron and is fully connected to the next layer. This architecture allows for massive parallel information processing.

Backpropagation: The Engine of Learning

How does the MLP find the right weights? Through Backpropagation.

Forward Pass: The network makes a prediction.
Error Measurement: We compare the prediction to the real answer.
Backward Pass: We distribute the "blame" for the error back through every single neuron using the Chain Rule of calculus.
Weight Update: Every weight is slightly adjusted (using Gradient Descent) to reduce the error for the next time.

Regression and Classification MLPs

MLPs are versatile.

Regression: To predict a number (e.g., Salary), the output layer has 1 neuron and no activation function (or ReLU to ensure positive numbers).
Classification: To predict a category (e.g., Department), the output layer has one neuron per category and uses the Softmax activation function to provide a probability distribution.

Implementing MLP with Keras

Keras is a high-level API for Tensorflow that makes building neural networks as easy as stacking Lego blocks. We use the Sequential API to define our layers in order.

The Developer Workflow: You define the model, compile it with an optimizer (learning rules), and then call model.fit(). The machine then handles all the complex matrix math and backpropagation for you automatically.

Python

# Building a network in 5 lines of Kerasfrom tensorflow import keras model = keras.models.Sequential([    keras.layers.Flatten(input_shape=[28, 28]), # Input    keras.layers.Dense(300, activation="relu"), # Large Hidden Layer    keras.layers.Dense(100, activation="relu"), # Smaller Hidden Layer    keras.layers.Dense(10, activation="softmax") # Output (10 classes)])

Fine-Tuning Hyperparameters

The power of a Neural Network comes from its "Hyperparameters"—the settings we choose before training starts. A poorly tuned network can take hours to learn nothing, while a well-tuned one can solve the problem in seconds.

Number of Neurons per Hidden Layer

Generally, you want many neurons in the first layer and gradually fewer as you get closer to the output—like a funnel filter. However, modern research suggests that using many layers with a moderate number of neurons is often better than one giant layer with thousands of neurons (a "Deep" vs "Wide" strategy).

Learning Rate & Batch Size

Learning Rate is the most critical hyperparameter. If it's too high, the model "diverges" (explodes); if it's too low, it will take millions of years to learn. Batch Size determines how many examples the model looks at before updating weights. Smaller batches add noise (which can help skip over local errors), while larger batches are more stable but memory-hungry.

Python

# Changing the Batch Size# batch_size=32 is standard# batch_size=1  is Stochastic (Fast but shaky)# batch_size=None is Full Batch (Slow but precise)

Other Hyperparameters (Epochs, Activation)

You'll also tune the Number of Epochs (how many times the model sees the whole data) and the Activation Function (ReLU is the standard). Finding the "Sweet Spot" for these values is the core job of a Deep Learning Engineer.

The Road to Deep Learning

Congratulations! You've mastered the fundamentals of Machine Learning—from cleaning raw HR data to building your first Artificial Neural Network. Machine Learning is about choosing the right algorithms; Deep Learning (our next course) is about building massive, hierarchical networks that can learn to see, listen, and reason.

What's Next? In the Deep Learning course, we'll dive into Convolutional Networks (Vision), RNNs (Sequential Data), and the powerful Transformers that revolutionized AI. See you there!

Capstone: The Mature HR Intelligence Model

To close this course, let's look at what a Mature Machine Learning Model looks like in a global enterprise. It isn't just a single algorithm; it's a "Pipeline" that synthesizes everything we've covered.

The Final Achievement:

Data Unification (Ch 2): Merging global payroll, survey, and performance shards.
Dimension Reduction (Ch 5): Using PCA to condense 200 features into 5 core "Employee DNA" vectors.
Ensemble Voting (Ch 4): A Random Forest provides a stable baseline risk score.
Neural Network (Ch 6): A Keras MLP performs the final, high-precision churn prediction.
Monitoring (Ch 2/3): Automated drift detection alerts the HR team if the model needs retraining.

This is the standard for modern "Talent Intelligence" platforms. You are now equipped to build, lead, and deploy these systems in the real world.

Python

# CAPSTONE: The End-to-End HR Intelligence Pipelineclass HRIntelligenceSystem:    def __init__(self):        print("Initializing Mature HR System...")            def preprocess(self, raw_data):        # Step 1: Unification & Scaling (Ch 2)        return "Cleaned & Scaled Vectors"            def reduce_dimensions(self, cleaned_data):        # Step 2: PCA (Ch 5)        return "Core Talent Pillars (3 Dimensions)"            def predict(self, core_pillars):        # Step 3: Ensemble + Neural Net (Ch 4 & 6)        # Combine RF stability with MLP precision        return "92% Probability: High Potential (Ready for Promotion)"            def monitor(self, result):        # Step 4: Drift Detection (Ch 2)        return "✅ Model Healthy" # Execute the Course Achievementsystem = HRIntelligenceSystem()cleansed = system.preprocess("Raw Global Data")pillars  = system.reduce_dimensions(cleansed)result   = system.predict(pillars) print(f"Final Decision: {result}")print(f"System Status : {system.monitor(result)}")

PythonRuns entirely in your browser — nothing is sent to a server.

[{"label":"The Neuron: Firing Logic","code":"# Simulating a single Artificial Neuron (TLU)\n# Logic: If (Score * Weight) + Bias > 0, the neuron 'fires' (1)\ndef artificial_neuron(inputs, weights, bias=-5):\n    weighted_sum = sum(i * w for i, w in zip(inputs, weights)) + bias\n    return 1 if weighted_sum > 0 else 0\n\n# Input: [Experience=8, Python_Skill=7] | Weights: [0.5, 0.3]\nweights = [0.5, 0.3]\nprint(f\"Candidate A (Experienced): {artificial_neuron([8, 7], weights)}\") # Fires 1\nprint(f\"Candidate B (Junior):      {artificial_neuron([1, 2], weights)}\") # Fires 0"},{"label":"Keras: Simple Skill Predictor","code":"# Simulated Keras Workflow (Tensorflow API)\n# Since the browser environment is lightweight, we use a 'Conceptual Model'\nclass MockKerasModel:\n    def __init__(self, layers):\n        self.layers = layers\n    def compile(self, loss, optimizer):\n        self.loss = loss\n        self.optimizer = optimizer\n    def summary(self):\n        return f\"Model: 'Sequential'\\n_________________________________________________________________\\nLayer (type)                Output Shape              Param #   \\n=================================================================\\ndense (Dense)               (None, 30)                330       \\ndense_1 (Dense)             (None, 1)                 31        \\n=================================================================\\nTotal params: 361\\nTrainable params: 361\\nNon-trainable params: 0\\n\"\n\n# 1. Define Architecture (Conceptual)\nmodel = MockKerasModel(layers=[\"Dense(30)\", \"Dense(1)\"])\n\n# 2. Compile with Optimizer\nmodel.compile(loss=\"binary_crossentropy\", optimizer=\"sgd\")\n\nprint(\"Neural Network successfully initialized (Simulated)!\")\nprint(model.summary())"},{"label":"Hyperparameters: Learning Rate","code":"# Visualizing why Learning Rate is the 'Most Important Knob'\ndef train_simulation(lr):\n    path = [10.0]\n    for _ in range(5):\n        # Nudging toward zero (the 'answer')\n        current = path[-1]\n        step = current * lr\n        path.append(current - step)\n    return path\n\nprint(f\"Small LR (0.1) - Steady: {train_simulation(0.1)}\")\nprint(f\"Large LR (0.9) - Fast:   {train_simulation(0.9)}\")\nprint(f\"Crazy LR (1.5) - Chaos:  {train_simulation(1.5)}\")"}]

[{"label":"The Neuron: Firing Logic","code":"# Simulating a single Artificial Neuron (TLU)\n# Logic: If (Score * Weight) + Bias > 0, the neuron 'fires' (1)\ndef artificial_neuron(inputs, weights, bias=-5):\n    weighted_sum = sum(i * w for i, w in zip(inputs, weights)) + bias\n    return 1 if weighted_sum > 0 else 0\n\n# Input: [Experience=8, Python_Skill=7] | Weights: [0.5, 0.3]\nweights = [0.5, 0.3]\nprint(f\"Candidate A (Experienced): {artificial_neuron([8, 7], weights)}\") # Fires 1\nprint(f\"Candidate B (Junior):      {artificial_neuron([1, 2], weights)}\") # Fires 0"},{"label":"Keras: Simple Skill Predictor","code":"# Simulated Keras Workflow (Tensorflow API)\n# Since the browser environment is lightweight, we use a 'Conceptual Model'\nclass MockKerasModel:\n    def __init__(self, layers):\n        self.layers = layers\n    def compile(self, loss, optimizer):\n        self.loss = loss\n        self.optimizer = optimizer\n    def summary(self):\n        return f\"Model: 'Sequential'\\n_________________________________________________________________\\nLayer (type)                Output Shape              Param #   \\n=================================================================\\ndense (Dense)               (None, 30)                330       \\ndense_1 (Dense)             (None, 1)                 31        \\n=================================================================\\nTotal params: 361\\nTrainable params: 361\\nNon-trainable params: 0\\n\"\n\n# 1. Define Architecture (Conceptual)\nmodel = MockKerasModel(layers=[\"Dense(30)\", \"Dense(1)\"])\n\n# 2. Compile with Optimizer\nmodel.compile(loss=\"binary_crossentropy\", optimizer=\"sgd\")\n\nprint(\"Neural Network successfully initialized (Simulated)!\")\nprint(model.summary())"},{"label":"Hyperparameters: Learning Rate","code":"# Visualizing why Learning Rate is the 'Most Important Knob'\ndef train_simulation(lr):\n    path = [10.0]\n    for _ in range(5):\n        # Nudging toward zero (the 'answer')\n        current = path[-1]\n        step = current * lr\n        path.append(current - step)\n    return path\n\nprint(f\"Small LR (0.1) - Steady: {train_simulation(0.1)}\")\nprint(f\"Large LR (0.9) - Fast:   {train_simulation(0.9)}\")\nprint(f\"Crazy LR (1.5) - Chaos:  {train_simulation(1.5)}\")"}]

Practice Questions

Question 1

What is 'Backpropagation'?

The process of deleting old data
A technique where the model distributes error back through the network to update weights
A way to speed up the internet
An algorithm for sorting files

Question 2

Which hyperparameter is generally considered the most important to tune correctly?

Number of layers
Activation function
Learning Rate
Batch Size

Question 3

What is the primary goal of the 'Hidden Layers' in an MLP?

To hide data from the user
To store the training labels
To extract complex, hierarchical features and non-linear patterns from the input data
To increase the speed of the CPU