Deep Learning and Machine Learning: Advancing Big Data

Analytics and Management

arXiv:2410.01268v1 [cs.CL] 2 Oct 2024

Pohsun Feng*† Ziqian Bi*† Yizhu Wen*

National Taiwan Normal University Indiana University University of Hawaii
[email protected] [email protected] [email protected]

Xuanhe Pan Benji Peng

University of Wisconsin-Madison AppCubic
[email protected] [email protected]

Ming Liu Jiawei Xu Keyu Chen

Purdue University Purdue University Georgia Institute of Technology
[email protected] [email protected] [email protected]

Junyu Liu Caitlyn Heqi Yin

Kyoto University University of Wisconsin-Madison
[email protected] [email protected]

Sen Zhang Jinlang Wang

Rutgers University University of Wisconsin-Madison
[email protected] [email protected]

Qian Niu Ming Li

Kyoto University Georgia Institute of Technology
[email protected] [email protected]

Tianyang Wang
Xi’an Jiaotong-Liverpool University
[email protected]
2

"The more you buy,The more you save."

— Jensen Huang, CEO of NVIDIA

* Equal contribution
† Corresponding author
Contents

II Getting Started 13

1 A Journey into Artificial Intelligence 15

1.1 The Rise of Machine Learning and Deep Learning . . . . . . . . . . . . . . . . . . . . . . 15
1.1.1 From Basics to Intelligence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.1.2 Deep Learning: The Driving Force of the Future . . . . . . . . . . . . . . . . . . . 15
1.2 Applications Everywhere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2.1 The Power to Transform the World . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2.2 The Future is Here . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3 The Future of AI: The Next Technological Wave . . . . . . . . . . . . . . . . . . . . . . . 16
1.3.1 Automated Machine Learning: Democratizing AI . . . . . . . . . . . . . . . . . . . 16
1.3.2 Edge Computing: Bringing AI Closer to You . . . . . . . . . . . . . . . . . . . . . . 16
1.3.3 Explainability and Fairness in AI . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.4 Visualization: Seeing the World Behind Data . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.5 The Beginner’s Journey in AI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2 Making the Best Use of Tools 19

2.1 ChatGPT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.1.1 Data Analysis and Direction Setting . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.1.2 Machine Learning and Deep Learning Model Design . . . . . . . . . . . . . . . . 20
2.1.3 Code Writing and Optimization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2 Claude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2.1 Big Data Processing and Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2.2 Machine Learning Model Optimization and Tuning . . . . . . . . . . . . . . . . . 20
2.3 Gemini . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.1 Multimodal Reasoning and Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.3.2 Deep Learning Model Design and Optimization . . . . . . . . . . . . . . . . . . . 21
2.4 Other Multimodal AI Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.4.1 CodeWhisperer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.4.2 Copilot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.4.3 Replit Ghostwriter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3 Choosing Computer Hardware for Programming and ML 23

3.1 Example Configurations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.1.1 A High-End DDR4 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3
4 CONTENTS

Configurations and Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.1.2 A High-End DDR4 ThreadRipper Configuration . . . . . . . . . . . . . . . . . . . . 25
Choosing the Processor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Motherboard Selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Cooling Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Memory Selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.1.3 A High-End DDR4 Server Configuration . . . . . . . . . . . . . . . . . . . . . . . . 27
Choosing the Processor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Motherboard Selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Cooling Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Memory Selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Other Considerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.1.4 A High-End DDR5 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.1.5 Configuration and Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2 Hardware Considerations for Programming . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2.1 Processor (CPU) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2.2 Memory (RAM) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2.3 Storage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3 Hardware for Machine Learning and Deep Learning . . . . . . . . . . . . . . . . . . . . . 31
3.3.1 Processor (CPU) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.3.2 Graphics Processing Unit (GPU) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
NVIDIA GPUs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Apple’s Metal Performance Shaders (MPS) . . . . . . . . . . . . . . . . . . . . . . 32
AMD ROCm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Memory Considerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.3.3 Memory (RAM) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.3.4 Storage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.3.5 Other Considerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.4 Making Informed Decisions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4 Setting Up Your Development Environment 35

4.1 Installing Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.1.1 Downloading Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.1.2 Installing on Windows/Mac/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.1.3 Verifying the Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.2 Setting Up a Virtual Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.2.1 Importance of Virtual Environments . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.2.2 Creating a Virtual Environment with conda . . . . . . . . . . . . . . . . . . . . . . 37
4.2.3 Activating/Deactivating a Virtual Environment . . . . . . . . . . . . . . . . . . . . 37
4.3 Installing Essential Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.3.1 Using pip to Install Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.3.2 Commonly Used Packages (e.g., numpy, pandas, matplotlib) . . . . . . . . . . . . 38
4.3.3 Installing Special Packages - PyTorch and CUDA . . . . . . . . . . . . . . . . . . 38
Introduction to CUDA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Installing a CUDA-Enabled PyTorch . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Verifying PyTorch CUDA Support . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
CONTENTS 5

4.3.4 Installing Special Packages - TensorFlow and CUDA . . . . . . . . . . . . . . . . 39

4.3.5 Managing Dependencies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.4 Setting Up an Integrated Development Environment (IDE) . . . . . . . . . . . . . . . . . . 41
4.4.1 Introduction to Popular IDEs (e.g., PyCharm, VSCode) . . . . . . . . . . . . . . . . 41
4.4.2 Setting Up and Configuring Your IDE . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.4.3 Recommended VSCode Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . 42

5 Introduction to Python Programming 43

5.1 Hello World . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.1.1 Hello World — Printing a String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.1.2 Hello World — Defining a Function . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.1.3 Hello World — Using if __name__ == "__main__" . . . . . . . . . . . . . . . . . . 44
5.2 Data Types in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.2.1 Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Example 1: Integer and Float Addition . . . . . . . . . . . . . . . . . . . . . . . . . 45
Example 2: Float and Complex Number Addition . . . . . . . . . . . . . . . . . . . 45
Example 3: Division of Integers Results in a Float . . . . . . . . . . . . . . . . . . 46
Example 4: Integer Division Using // . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Example 5: Modulus and Power Operations . . . . . . . . . . . . . . . . . . . . . 46
5.2.2 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Common String Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
String Formatting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3 Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.3.1 Common List Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.3.2 Nested Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.4 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.5 Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
5.6 Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
5.7 Variables in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.7.1 Global and Local Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.7.2 Call by Object Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Mutable Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Immutable Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
5.8 Floating-Point Precision Issues in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
5.8.1 The Cause of Floating-Point Precision Issues . . . . . . . . . . . . . . . . . . . . 54
5.8.2 Which Programming Languages Have Similar Issues? . . . . . . . . . . . . . . . 54
5.8.3 The Real Impact of Floating-Point Operations . . . . . . . . . . . . . . . . . . . . 54
5.8.4 How to Handle Floating-Point Precision in Python . . . . . . . . . . . . . . . . . . 55
5.8.5 Banker’s Rounding and Floating-Point Precision . . . . . . . . . . . . . . . . . . . 55
5.9 Basic Control Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
5.9.1 Logical Operators: and, or, not . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
and Operator: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
or Operator: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
not Operator: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
5.9.2 Conditional Statements: if, elif, else . . . . . . . . . . . . . . . . . . . . . . . . 57
5.9.3 Loops: for and while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
6 CONTENTS

for Loop: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Specifying Start and Stop Values . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Using a Step Value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Using Negative Step Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
while Loop: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Breaking and Continuing in Loops: . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
break: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
continue: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Combining break and continue: . . . . . . . . . . . . . . . . . . . . . . . . 61
5.10 Functions in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
5.10.1 def Keyword and Function Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Basic Example: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Functions with Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Functions with Multiple Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Returning Values from Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Default Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.10.2 Recursion in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Basic Example of Recursion: Factorial Function . . . . . . . . . . . . . . . . . . . 64
Recursive Fibonacci Sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Base Case and Recursive Case . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Caution with Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
5.11 Simple Sorting Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.11.1 Bubble Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.11.2 Insertion Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.11.3 Python’s Built-in sort() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.11.4 Comparing the Time of Bubble Sort, Insertion Sort, and Python’s Built-in sort() . 68

6 Python for Data Science 71

6.1 Commonly used Datasets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
6.1.1 Iris Dataset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

7 Introduction to Machine Learning 77

7.1 What is Machine Learning? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
7.1.1 Definition and Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
7.1.2 History and Evolution of Machine Learning . . . . . . . . . . . . . . . . . . . . . . 78
7.1.3 Machine Learning vs. Traditional Programming . . . . . . . . . . . . . . . . . . . 79
7.2 Types of Machine Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
7.2.1 Supervised Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Concept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Working Principle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Common Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Application Scenarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Advantages and Disadvantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Advantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Disadvantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Detailed Explanation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
CONTENTS 7

Concrete Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
7.2.2 Unsupervised Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Concept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Working Principle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Steps in Unsupervised Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Common Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Unsupervised Learning Techniques . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Application Scenarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Applications of Data Analysis Techniques . . . . . . . . . . . . . . . . . . . . . . 84
Advantages and Disadvantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Advantages and Disadvantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Advantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Disadvantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Concrete Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
7.2.3 Semi-supervised Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Concept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Working Principle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Semi-Supervised Learning Process . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Common Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Semi-Supervised Learning Methods . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Application Scenarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Advantages and Disadvantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Advantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Disadvantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Concrete Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
7.2.4 Reinforcement Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Concept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Working Principle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Agent Interaction Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Key Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Key Concepts in Reinforcement Learning . . . . . . . . . . . . . . . . . . . . . . . 88
Common Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Reinforcement Learning Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Application Scenarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Advantages and Disadvantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Advantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Disadvantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Concrete Example: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Game Setup: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Environment Definition: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Q-table Initialization: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Learning Parameters: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Training Process (Q-learning algorithm): . . . . . . . . . . . . . . . . . . . 90
Evaluation: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Results Analysis: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
8 CONTENTS

Visualization: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Further Improvements: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
7.3 Key Concepts and Terminologies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
7.3.1 Features and Labels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
7.3.2 Training Data and Test Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
7.3.3 Model, Algorithm, and Hyperparameters . . . . . . . . . . . . . . . . . . . . . . . 92
7.4 Machine Learning Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
7.4.1 Data Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
7.4.2 Data Preprocessing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.4.3 Model Selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.4.4 Training and Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.4.5 Model Deployment and Monitoring . . . . . . . . . . . . . . . . . . . . . . . . . . 94
7.5 Common Algorithms in Machine Learning . . . . . . . . . . . . . . . . . . . . . . . . . . 94
7.5.1 Linear Regression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
7.5.2 Logistic Regression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
7.5.3 Decision Trees and Random Forests . . . . . . . . . . . . . . . . . . . . . . . . . 96
7.5.4 Support Vector Machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
7.5.5 Clustering Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.6 Challenges in Machine Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.6.1 Overfitting and Underfitting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.6.2 Bias-Variance Tradeoff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.6.3 Data Quality and Quantity Issues . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.6.4 Ethical Concerns and Bias in AI . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.7 Machine Learning Tools and Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.7.1 Overview of Popular Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.7.2 Choosing the Right Tool for Your Task . . . . . . . . . . . . . . . . . . . . . . . . 98
7.7.3 Integration with Data Processing Tools . . . . . . . . . . . . . . . . . . . . . . . . 99
7.8 Practical Examples and Case Studies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
7.8.1 Example Projects Using Supervised Learning . . . . . . . . . . . . . . . . . . . . 99
7.8.2 Unsupervised Learning in Action . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
7.8.3 Real-world Applications of Reinforcement Learning . . . . . . . . . . . . . . . . . 100
7.9 Summary and Future Directions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
7.9.1 Recap of Key Points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
7.9.2 Emerging Trends in Machine Learning . . . . . . . . . . . . . . . . . . . . . . . . 100
7.9.3 Further Reading and Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

8 Understanding Neural Networks 103

8.1 Introduction to Neural Networks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
8.2 The Perceptron . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
8.2.1 Mathematical Foundations of the Perceptron . . . . . . . . . . . . . . . . . . . . 103
8.2.2 Limitations of the Perceptron . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
8.3 Multilayer Perceptrons (MLP) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
8.3.1 Architecture of MLP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
8.3.2 Activation Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
8.4 Feedforward Neural Networks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
8.4.1 Forward Propagation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
CONTENTS 9

8.4.2 Loss Functions and Objective Functions . . . . . . . . . . . . . . . . . . . . . . . 105

8.5 Backpropagation and Gradient Descent . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
8.5.1 Gradient Descent Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
8.5.2 Backpropagation Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
8.5.3 Optimization Techniques (SGD, Adam, etc.) . . . . . . . . . . . . . . . . . . . . . 107
8.6 Weight Initialization and Regularization . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
8.6.1 Importance of Weight Initialization . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Xavier Initialization: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
He Initialization: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
8.6.2 Overfitting and Regularization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
L1 and L2 Regularization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
L1 Regularization (Lasso): . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
L2 Regularization (Ridge or Weight Decay): . . . . . . . . . . . . . . . . . . 108
Dropout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
8.7 Convolutional Neural Networks (CNNs) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
8.7.1 Introduction to CNNs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
8.7.2 Convolutional Layers and Pooling . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Pooling Layers: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
8.7.3 Applications of CNNs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
8.8 Recurrent Neural Networks (RNNs) and Variants . . . . . . . . . . . . . . . . . . . . . . . 110
8.8.1 Introduction to RNNs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
8.8.2 Long Short-Term Memory (LSTM) . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
8.8.3 Gated Recurrent Units (GRU) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
8.8.4 Applications of RNNs, LSTMs, and GRUs . . . . . . . . . . . . . . . . . . . . . . . 111
8.9 Advanced Neural Network Architectures . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
8.9.1 Autoencoders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
8.9.2 Generative Adversarial Networks (GANs) . . . . . . . . . . . . . . . . . . . . . . . 112
8.9.3 Transformers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
8.9.4 Applications of Advanced Neural Architectures . . . . . . . . . . . . . . . . . . . 112
8.10 Hyperparameter Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.10.1 Common Hyperparameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Learning Rate: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Batch Size: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Number of Layers and Neurons: . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Dropout Rate: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Weight Initialization: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Optimizer: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.10.2 Grid Search, Random Search, and Bayesian Optimization . . . . . . . . . . . . . . 114
Grid Search: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Random Search: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Bayesian Optimization: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Choosing an Optimization Method . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
8.11 Practical Considerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
8.11.1 Hardware Requirements for Training Neural Networks . . . . . . . . . . . . . . . 114
Graphics Processing Units (GPUs): . . . . . . . . . . . . . . . . . . . . . . . . . . 115
10 CONTENTS

Tensor Processing Units (TPUs): . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

Memory and Storage: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
8.11.2 Training and Inference Speed Considerations . . . . . . . . . . . . . . . . . . . . 115
Batch Size and Learning Rate: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Model Parallelism and Data Parallelism: . . . . . . . . . . . . . . . . . . . . . . . 115
Inference Optimization: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
8.11.3 Model Deployment and Scalability . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Scalability: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Deployment in Cloud Environments: . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Edge Deployment and Energy Efficiency: . . . . . . . . . . . . . . . . . . . . . . . 116
Monitoring and Maintenance: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

9 Getting Started with Deep Learning 117

9.1 AI Environment Setup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
9.1.1 Installing Deep Learning Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
9.1.2 GPU Setup for Deep Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
9.2 Introduction to TensorFlow and PyTorch . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
9.2.1 Overview of TensorFlow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
9.2.2 Overview of PyTorch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
9.3 Building Your First Deep Learning Model . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
9.3.1 Dataset Preparation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
9.3.2 Defining the Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
9.3.3 Compiling and Training the Model . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
9.4 Evaluating and Fine-Tuning Your Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
9.4.1 Evaluating Model Performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
9.4.2 Saving and Loading Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
9.4.3 Basic Hyperparameter Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
9.5 Implementing More Complex Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
9.5.1 Convolutional Neural Networks (CNNs) . . . . . . . . . . . . . . . . . . . . . . . . 126
9.5.2 Recurrent Neural Networks (RNNs) . . . . . . . . . . . . . . . . . . . . . . . . . . 127
9.6 Using Pre-trained Models and Transfer Learning . . . . . . . . . . . . . . . . . . . . . . . 128
9.6.1 Introduction to Transfer Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
9.6.2 Using Pre-trained Models in TensorFlow and PyTorch . . . . . . . . . . . . . . . . 129
9.6.3 Fine-tuning a Pre-trained Model on a Custom Dataset . . . . . . . . . . . . . . . . 131
9.7 Practical Considerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
9.7.1 Model Deployment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
9.7.2 Optimizing for Speed and Performance . . . . . . . . . . . . . . . . . . . . . . . . 133

10 Data Visualization 135

10.1 The Importance of Data Visualization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
10.2 Commonly used Visualization Charts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
10.2.1 Line Chart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
10.2.2 Pie Chart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
10.2.3 Bar Chart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
10.2.4 Histogram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
10.2.5 Parallel Coordinates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
CONTENTS 11

10.2.6 Iris Dataset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

10.2.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
12 CONTENTS
 Part II

Getting Started

13
Chapter 1

A Journey into Artificial Intelligence

Welcome to the world of deep learning and machine learning! In this era full of infinite possibilities,
artificial intelligence (AI) is no longer just a concept from science fiction but is becoming an integral
part of our daily lives. From voice assistants in smartphones to self-driving cars, AI is redefining the
world around us. If you’re a beginner looking for a gateway into this vast field, this chapter will open a
window to the history, applications, and future trends of AI, giving you an exciting overview of what’s
to come.

1.1 The Rise of Machine Learning and Deep Learning

1.1.1 From Basics to Intelligence

The history of machine learning [79] dates back to the mid-20th century when scientists began to
explore the idea of whether machines could learn to solve problems. What once sounded like a fantasy
is now a reality. The core idea of machine learning is to enable computers to identify patterns in data
and use them to make predictions, classify objects, or solve complex tasks. Deep learning, a branch of
machine learning inspired by neural networks in the human brain, has taken this concept even further,
allowing machines to handle more intricate and abstract problems.

1.1.2 Deep Learning: The Driving Force of the Future

You may have heard stories like AlphaGo [91] defeating human Go masters, or perhaps you use an
AI-powered app every day. These advances are driven by deep learning. Since 2010, deep learning
has achieved remarkable results in areas such as image recognition, speech recognition, and natural
language processing, gaining widespread attention in both academia and industry. In many ways,
deep learning has become the engine of AI, powering its rapid advancement.

1.2 Applications Everywhere

1.2.1 The Power to Transform the World

Machine learning and deep learning are transforming numerous industries and impacting our everyday
lives in ways we never imagined:

15
16 CHAPTER 1. A JOURNEY INTO ARTIFICIAL INTELLIGENCE

• Smartphones and Daily Technology: Facial recognition on your phone, as well as voice assis-
tants that answer your questions, rely on powerful AI-driven image recognition and natural lan-
guage processing technologies.

• Autonomous Driving and Transportation: Self-driving cars are becoming a reality, thanks to
breakthroughs in machine learning, which enable them to perceive their environment, make de-
cisions, and plan routes.

• Healthcare Revolution: AI is helping doctors analyze medical images, predict disease trends,
and develop personalized treatment plans, elevating healthcare to new heights.

• Financial Services: In the financial sector, deep learning is used for fraud detection, market pre-
diction, and providing personalized investment advice.

1.2.2 The Future is Here

Whether it’s helping doctors diagnose diseases, assisting lawyers with legal document analysis, or
optimizing supply chains with big data, the applications of machine learning and deep learning have
already moved beyond the technology sector and are driving change across multiple industries.

1.3 The Future of AI: The Next Technological Wave

1.3.1 Automated Machine Learning: Democratizing AI

In the future, machine learning will no longer be the exclusive domain of experts. With the advent of
automated machine learning (AutoML), even individuals without deep technical knowledge will be able
to build AI models. This democratization of AI will lower the barriers to entry, allowing more people to
participate in this technological revolution.

1.3.2 Edge Computing: Bringing AI Closer to You

As the Internet of Things (IoT) expands, AI will shift from the cloud to local devices, known as “edge
computing.” This means that your smartwatch, home appliances, and even your car will have AI capa-
bilities, providing faster and more personalized services without relying on the cloud.

1.3.3 Explainability and Fairness in AI

As AI becomes increasingly integrated into society, transparency and fairness in its decision-making
processes will be critical. The future of AI research will focus on ensuring that AI systems are not only
powerful but also understandable and unbiased, promoting fairness across different social groups.

1.4 Visualization: Seeing the World Behind Data

For beginners, data and models can often seem complex and difficult to understand. Visualization,
however, serves as a key to unlocking the mysteries of AI. With graphical tools, complex algorithms,
and data structures become more intuitive. For example, visualization tools help illustrate how a deep
1.5. THE BEGINNER’S JOURNEY IN AI 17

learning model extracts features from images or text. Visualization not only aids learning but is also
an essential tool for debugging and optimizing models.

1.5 The Beginner’s Journey in AI

For those just starting, learning deep learning and machine learning may seem daunting, but with a
clear path, the journey can be fun and rewarding:

1. Solidify Your Math Foundation: Concepts like linear algebra, calculus, and probability are the
bedrock of machine learning. You don’t need to be a mathematician, but mastering these tools
will significantly enhance your understanding.

2. Learn to Code: Python is the most popular language in machine learning, and with libraries like
TensorFlow and PyTorch, you can easily build deep learning models.

3. Start with Simple Models: Classical algorithms like linear regression and decision trees are
great starting points. Once you understand the basics, you can move on to more complex deep-
learning models.

4. Hands-On Projects: Theory is important, but hands-on experience is where real learning hap-
pens. Start with publicly available datasets and gradually build and optimize your own AI mod-
els.

1.6 Conclusion
Deep learning and machine learning are reshaping the world, and you have the opportunity to be part
of this transformation. As you embark on this learning journey, you’ll not only master cutting-edge
technologies but also discover how to apply them creatively and meaningfully. Whether your goal
is to solve real-world problems with AI or explore the frontiers of research, the future holds endless
possibilities. Let’s step into this intelligent era together and embrace a brighter future!
18 CHAPTER 1. A JOURNEY INTO ARTIFICIAL INTELLIGENCE
Chapter 2

Making the Best Use of Tools

In today’s digital age, artificial intelligence (AI) tools have become widely adopted. These tools sig-
nificantly boost productivity and help us achieve more efficient outcomes in big data management
and analysis, machine learning, and deep learning. Particularly, natural language processing (NLP)
advancements have made multimodal AI tools incredibly powerful. These tools can understand and
generate natural language and analyze multimodal inputs (such as text, images, and code) to assist
users in solving complex tasks.
The utility of these AI tools goes beyond just coding. They can be used to ask questions, explore
ideas, confirm research directions, and solve technical issues. In big data management and machine
learning projects, AI tools are invaluable for quickly exploring data, designing and optimizing models,
and increasing the overall efficiency of research and development. This chapter will introduce several
of the most popular AI tools today and explain how to make the best use of them to enhance your
work in big data and machine learning.

2.1 ChatGPT

ChatGPT [73], developed by OpenAI, is a powerful conversational AI tool [16]. It can not only understand
and generate natural language but also assist developers in data analysis, model design, and code
generation [21]. ChatGPT excels in providing detailed suggestions based on context and continuously
refines its responses through ongoing dialogue with the user. This makes ChatGPT a valuable tool for
solving complex problems and determining research directions.

2.1.1 Data Analysis and Direction Setting

In the process of big data analysis, ChatGPT can assist users in understanding data distributions,
selecting features, and performing data cleaning tasks. Users can inquire about specific analysis
methods, the details of algorithmic models, or how to select the best model for processing their data.
ChatGPT can also help users narrow down their scope of analysis and develop effective strategies by
discussing and answering specific questions.

19
20 CHAPTER 2. MAKING THE BEST USE OF TOOLS

2.1.2 Machine Learning and Deep Learning Model Design

ChatGPT is highly effective in the field of machine learning and deep learning. It can help users under-
stand the workings of different algorithms and provide suggestions on adjusting model parameters
to improve performance. During model design, ChatGPT can offer advice on selecting activation func-
tions, optimizers, and loss functions, ensuring that the constructed model is well-tuned and logical.

2.1.3 Code Writing and Optimization

Beyond direction setting and model design, ChatGPT can also generate code snippets based on user
requirements. For example, if a user describes a machine learning algorithm, ChatGPT can provide
the corresponding code implementation. Supporting multiple programming languages, it helps de-
velopers quickly prototype algorithms. Additionally, in terms of code optimization, ChatGPT can help
simplify complex code structures and improve execution efficiency.

2.2 Claude

Claude, developed by Anthropic [6], is another powerful conversational AI tool. It is particularly well-
suited for projects that require a high level of security and robustness, making it a strong fit for big data
analysis and machine learning tasks. Claude not only helps with code generation but is also adept at
performing data processing, analysis, and security review in model design.

2.2.1 Big Data Processing and Analysis

In big data management and analysis, data security and accuracy are paramount [27]. Claude can
analyze the characteristics of datasets and help developers design more robust algorithms, ensuring
privacy protection during data processing [18]. Developers can use Claude to design distributed data
processing pipelines, identify key features, and detect potential anomalies in the data.

2.2.2 Machine Learning Model Optimization and Tuning

Claude stands out in model optimization and tuning, especially when aiming for robustness. It helps
users understand how different algorithms apply to large-scale data and offers suggestions for param-
eter tuning, ensuring the generated models generalize well [60]. When working with private or sensitive
data, Claude’s security insights are invaluable in ensuring the model is compliant and secure.

2.3 Gemini

Gemini, developed by Google DeepMind, is a multimodal AI tool that combines powerful language
understanding with the ability to process multiple input types [25]. Gemini not only assists with code
generation and optimization but also helps users perform big data analysis and multimodal reasoning,
making it an ideal tool for complex data analysis and model design [9].
2.4. OTHER MULTIMODAL AI TOOLS 21

2.3.1 Multimodal Reasoning and Analysis

Gemini’s greatest strength lies in its multimodal reasoning capability. In big data analysis and machine
learning projects, users can input textual descriptions, code snippets, or images, and Gemini will com-
bine this information for deeper reasoning and analysis. This multimodal capability is particularly ad-
vantageous when working with diverse data or when designing models for complex, cross-disciplinary
tasks.

2.3.2 Deep Learning Model Design and Optimization

For deep learning models, especially in image processing and natural language processing, Gemini
assists users in designing and optimizing neural network structures. Users can seek advice on model
architectures (such as convolutional neural networks, recurrent neural networks, or transformer mod-
els), and Gemini will provide suggestions for suitable architectures based on the input. It also helps
with hyperparameter tuning to improve model performance.

2.4 Other Multimodal AI Tools

In addition to ChatGPT, Claude, and Gemini, there are many other multimodal conversational AI tools
available that can also assist developers and data scientists in big data management, machine learn-
ing, and deep learning.

2.4.1 CodeWhisperer

CodeWhisperer, developed by Amazon, is an AI code assistant integrated into IDEs such as Visual
Studio Code. It is particularly useful for cloud computing and machine learning tasks on big data [4].
CodeWhisperer not only offers contextual code completions but is also seamlessly integrated with
AWS services, making it an ideal choice for developers working on cloud-based machine learning and
data processing tasks.

2.4.2 Copilot

GitHub Copilot, powered by OpenAI Codex, is an AI code assistant that can help write and optimize
code, especially in complex machine learning projects [31]. For data scientists, Copilot simplifies many
time-consuming tasks, such as writing model code, by offering real-time code suggestions tailored to
the user’s coding habits.

2.4.3 Replit Ghostwriter

Replit Ghostwriter is an AI code assistant on the Replit platform, offering online programming and
real-time data analysis [84]. It is particularly useful for interactive machine-learning experiments and
coding within a browser. Ghostwriter provides instant feedback, helping users optimize model code
and visualize data analysis on the fly.
22 CHAPTER 2. MAKING THE BEST USE OF TOOLS

2.5 Conclusion
The use of AI tools has become an essential skill for modern data scientists and developers. By ef-
fectively leveraging tools such as ChatGPT, Claude, Gemini, and others, developers can significantly
enhance their efficiency in big data management, machine learning, and deep learning. From setting
research directions to optimizing algorithmic models, these tools offer robust support. As AI tech-
nology continues to evolve, we can expect these tools to become even more intelligent and easier to
use.
Chapter 3

Choosing Computer Hardware for

Programming and ML

In this chapter, we will explain the importance of selecting the right computer hardware for various
tasks, from general programming to more demanding machine learning and deep learning workloads.
The hardware you choose can significantly affect both your productivity and the performance of your
applications.

3.1 Example Configurations

The x86 platform primarily utilizes CPUs from Intel and AMD. However, in recent years, Intel’s intro-
duction of big.LITTLE architecture and various blue screen issues have raised concerns. While Intel
offers specific optimizations for gaming, it doesn’t provide significant advantages for programming
tasks. Therefore, we recommend AMD-based configurations, which offer better value for money and
are generally more stable.
About Overclocking: Although overclocking is quite popular among gaming enthusiasts, it is not
recommended for systems used in programming or deep learning tasks. These workloads prioritize
stability, and deep learning in particular demands much longer processing times and heavier work-
loads compared to gaming. This means the computer’s endurance is more critical. For beginners, it
is important to remember that maintaining system stability is key, especially when handling intensive
computational tasks.

3.1.1 A High-End DDR4 Configuration

Configurations and Analysis

1. Processor (CPU): AMD Ryzen 9 5950X

• 16 cores, 32 threads
• Base frequency: 3.4 GHz, Max boost frequency: 4.9 GHz
• TDP: 105W
• Architecture: Zen 3
Why it suits deep learning: A powerful multi-core processor is essential. The AMD Ryzen 9 5950X,
with its 16 cores and 32 threads, efficiently handles tasks like data preprocessing, model compilation,

23
24 CHAPTER 3. CHOOSING COMPUTER HARDWARE FOR PROGRAMMING AND ML

and task distribution, which are CPU-intensive. 32 threads allows parallel processing, particularly in
multi-task and high-load environments, such as training multiple models or handling different datasets
simultaneously.
2. Graphics Card (GPU): NVIDIA GeForce RTX 3090
• Memory: 24 GB GDDR6X
• CUDA Cores: 10,496
• Tensor Cores: 328
• Memory Bandwidth: 936.2 GB/s
• Supports 8K resolution, ray tracing (RTX)
Why it suits deep learning: The NVIDIA RTX 3090 is an excellent choice for deep learning:
• Large VRAM: 24 GB of VRAM allows for loading and processing large neural networks and
datasets without frequent memory swapping, which is crucial for deep learning tasks such as
image processing and NLP.
• CUDA and Tensor Cores: The 10,496 CUDA cores and 328 Tensor cores significantly enhance
the parallel computing capability, accelerating matrix operations (such as matrix multiplication
in deep learning) and convolution operations. Tensor cores further accelerate FP16/FP32 calcu-
lations, improving performance during training and inference.
• High Memory Bandwidth: The 936.2 GB/s memory bandwidth ensures rapid data transfer be-
tween memory and processing units, reducing latency and enhancing training efficiency.
3. Memory (RAM): 32 GB x 4 DDR4 3200 MHz (128 GB total)
• Type: DDR4
• Frequency: 3200 MHz
• CAS latency: CL16 or lower
Why it suits deep learning: Deep learning requires handling large datasets, especially in tasks in-
volving computer vision and natural language processing. The 128 GB memory capacity allows loading
large datasets into memory at once, reducing the need for frequent data swapping between memory
and storage. This large memory capacity speeds up data preprocessing, batch loading, and in-memory
computations, minimizing memory bottlenecks. Additionally, the 3200 MHz frequency ensures fast
data transfer, improving system responsiveness.
4. Motherboard: B550/x570 Chipset
• Supports PCIe 4.0 (GPU slot)
• Supports overclocking
• Supports high-speed M.2 SSDs
Why it suits deep learning: The B550 chipset provides PCIe 4.0 support, which is critical for maxi-
mizing the performance of the RTX 3090 and NVMe SSD. While more affordable than the X570 chipset,
the B550 still offers essential high-end features, including support for overclocking, high-speed mem-
ory, and fast storage, making it a cost-effective choice for deep learning tasks without sacrificing
critical functionality.
5. Storage (SSD): 2TB NVMe SSD
• Read speed: ∼ 500 MB/s
• Write speed: ∼000 MB/s
• Interface: PCIe 4.0 (dependent on motherboard)
Why it suits deep learning: Deep learning involves frequent access to large datasets, and a high-
speed NVMe SSD significantly accelerates data loading and storage operations. The speed of an
NVMe SSD is crucial for tasks such as loading datasets, writing model weights, and saving check-
3.1. EXAMPLE CONFIGURATIONS 25

points during training. The 2TB capacity is sufficient to store multiple projects, datasets, and model
files, reducing the need to rely on external storage.
6. Storage (HDD): 16TB SATA HDD
• 7200 RPM, 256 MB cache
• Large capacity for data storage
Why it suits deep learning: The 16TB HDD is ideal for storing large amounts of archival data, back-
ups, and massive datasets that do not require frequent access. Although the read/write speed is
slower compared to SSDs, HDDs offer a much larger capacity, which is essential for long-term storage
in deep learning projects. This combination of SSD for performance and HDD for capacity provides
an efficient solution for handling both hot and cold data.
7. Power Supply: 1000W 80 PLUS Gold or Platinum Certified PSU
• Provides sufficient power for high-end GPU and multi-core CPU
• Power headroom for overclocking
Why it suits deep learning: The 1000W PSU ensures stable power delivery to high-performance
components such as the RTX 3090 and Ryzen 9 5950X, which are power-hungry during deep learning
workloads. The 80 PLUS Gold or Platinum certification guarantees high energy efficiency, which is
crucial for maintaining system stability and reliability during long-duration, high-load tasks. Addition-
ally, the extra power headroom allows for potential overclocking, ensuring future-proofing for more
demanding workloads.
8. Case: Full Tower Case
• Excellent thermal design and airflow management
• Supports multiple fans and liquid cooling solutions
Why it suits deep learning: Deep learning tasks often involve long periods of heavy GPU and CPU
usage, generating significant heat. A full tower case provides ample space for effective cooling solu-
tions, such as multiple fans or liquid cooling systems, ensuring optimal temperature control. Keeping
components cool under heavy load helps maintain system performance and longevity, preventing ther-
mal throttling and potential hardware damage.

3.1.2 A High-End DDR4 ThreadRipper Configuration

In this section, we will guide you through purchasing a high-end DDR4 ThreadRipper configuration on
eBay, specifically focusing on the 3995WX, 5975WX, and 5995WX processors. Currently, DDR4-based
CPUs are highly affordable, yet still deliver excellent performance, making them a cost-effective option.
DDR4 memory and components are also readily available, making it a suitable choice for high-end
users.

Choosing the Processor

ThreadRipper processors are ideal for high-end workstations or tasks requiring extreme multi-threading.
Here are the three processors you can find on eBay, along with their price trends:

• 3995WX: 64 cores and 128 threads, suitable for massively parallel computing or virtualization
environments. Originally priced at around $5,500, it can now be found on eBay for around $1,000
to $1,500, offering excellent value.

• 5975WX: 32 cores and 64 threads, ideal for applications requiring high parallel processing, such
as video rendering and 3D modeling. Originally priced around $3,200, current eBay prices are
26 CHAPTER 3. CHOOSING COMPUTER HARDWARE FOR PROGRAMMING AND ML

approximately $1,200.

• 5995WX: 64 cores and 128 threads, the most powerful in the ThreadRipper series, designed for
extreme workloads. Originally priced at around $6,500, it can now be found for about $3,000 on
eBay.

It’s important to note that the 3995WX and other ThreadRipper 3000 series processors use the
TRX40 chipset motherboards, while the ThreadRipper 5000 series (e.g., 5975WX and 5995WX) re-
quire the WRX80 chipset motherboards. Be sure to choose the correct motherboard based on your
processor.
When purchasing on eBay, be aware of vendor locks. For example, some 3995WX processors may
have a Lenovo lock, meaning they will only work on specific Lenovo-branded motherboards. Avoid
purchasing locked processors if you do not have a compatible motherboard.

Motherboard Selection

For the 3995WX, you should choose a motherboard that supports the TRX40 chipset, whereas the
5000 series ThreadRipper (like 5975WX and 5995WX) requires a WRX80 chipset motherboard. Here
are some recommended options:

• TRX40 Motherboards (for the 3995WX and other ThreadRipper 3000 series processors):

– ASUS ROG Zenith II Extreme Alpha

– MSI Creator TRX40
– Gigabyte TRX40 AORUS XTREME

• WRX80 Motherboards (for the 5995WX, 5975WX, and other ThreadRipper 5000 series proces-
sors):

– ASUS Pro WS WRX80E-SAGE SE WIFI

– Gigabyte WRX80 SU8

When searching for these models on eBay, ensure the product is free of vendor locks and comes
with all necessary accessories (e.g., I/O shields, M.2 screws, etc.).

Cooling Solution

ThreadRipper processors generate significant heat, and do not come with a stock cooler, so you will
need to choose a suitable cooling solution. The type of cooler you select will significantly affect the
system’s noise level. Below are common cooling options:

• Liquid Coolers (e.g., Corsair H150i RGB Pro XT): Liquid coolers can deliver efficient cooling while
maintaining low noise levels, making them ideal for users requiring a quiet work environment.
Liquid cooling systems typically produce minimal noise, perfect for home or office use.

• High-Efficiency Air Coolers (e.g., Noctua NH-U14S TR4-SP3): Air coolers also provide good
cooling but may generate more noise at higher fan speeds. Noctua, for example, offers high-end
air coolers known for their low noise levels, suitable for users sensitive to noise.
3.1. EXAMPLE CONFIGURATIONS 27

If using large, high-power fans (often referred to as "aggressive fans"), they can offer extreme
cooling efficiency but typically produce a significant amount of noise. This setup is often used for
server-grade equipment or specialized high-performance workstations. If you plan to use such a cool-
ing solution, we recommend installing your system in a soundproof server room or a dedicated rack
to mitigate noise interference in your work environment.
When installing the cooler, ensure it comes with the TR4 or SP3 mounting brackets, as traditional
coolers might not be compatible with the larger processor size.

Memory Selection

The ThreadRipper platform supports multi-channel memory, so we recommend starting with 32GB per
DIMM and using at least 128GB (4 x 32GB) or more to fully utilize the multi-channel capability. Here
are some recommended memory options:

• Corsair Vengeance LPX DDR4 3200MHz 32GB: A cost-effective option with good stability.

• G.Skill Ripjaws V DDR4 3200MHz 32GB: High-frequency memory, ideal for multi-tasking and
rendering workloads.

You can choose a 4-channel or 8-channel memory configuration to maximize memory bandwidth
and performance, depending on the motherboard’s maximum supported memory channels.

3.1.3 A High-End DDR4 Server Configuration

Next, we will discuss configuring a high-end DDR4 server based on AMD EPYC 7763 and 7773X pro-
cessors. With DDR4 memory prices dropping and the price of these processors significantly lower on
the second-hand market, this makes for a very cost-effective solution.

Choosing the Processor

AMD’s EPYC series processors are designed for server and data center environments. Here are two
recommended processors, along with their price trends:

• EPYC 7763: 64 cores and 128 threads, delivering excellent multi-threading performance, ideal for
highly concurrent workloads. Originally priced at around $7,800, it can now be found for about
$700 on eBay.

• EPYC 7773X: 64 cores and 128 threads, leveraging 3D V-Cache technology to provide larger
cache sizes, making it ideal for workloads requiring huge data caches, such as database pro-
cessing. Originally priced at $8,500, it can now be found for around $1,500 on eBay.

Be aware that these processors may have vendor locks (e.g., HP, Dell, or Lenovo lock), meaning
they will only work on specific branded motherboards. Make sure the processor is compatible with
your motherboard before purchasing.

Motherboard Selection

EPYC processors require motherboards with the SP3 socket. Here are some common motherboard
options:
28 CHAPTER 3. CHOOSING COMPUTER HARDWARE FOR PROGRAMMING AND ML

• Supermicro H12SSL-i

• Gigabyte MZ72-HB0

• ASUS KGPE-D16

When searching for these motherboards on eBay, ensure that the product includes all necessary
accessories, particularly the I/O shield and cooling components.

Cooling Solution

EPYC processors also do not come with stock coolers, so you will need to purchase a cooler that
supports the SP3 socket. Below are recommended coolers:

• Noctua NH-U14S TR4-SP3: An air cooler offering excellent cooling performance for the SP3
socket.

• Dynatron A39 Server Cooler: A small, efficient cooler suitable for server setups.

Ensure that the cooler comes with the correct SP3 mounting hardware to guarantee proper instal-
lation.

Memory Selection

EPYC processors support DDR4 RDIMM or LRDIMM. We recommend starting with 32GB per DIMM
and using an 8-channel configuration. The minimum recommended memory configuration is 256GB
(8 x 32GB). Below are some memory options:

• Samsung DDR4 3200MHz RDIMM

• Micron DDR4 3200MHz LRDIMM

Make sure that the memory type is compatible with your motherboard and processor, and we rec-
ommend using multi-channel memory configurations to maximize overall performance.

Other Considerations

For a server configuration, especially one based on the EPYC 7763 or 7773X processors, you should
also consider the following hardware:

• Power Supply: A high-wattage power supply is necessary for server systems. We recommend
at least 1200W with 80 Plus Platinum certification.

• Chassis: Choose a chassis that supports multi-point cooling and large-sized motherboards. You
can consider rackmount chassis from brands like Supermicro or Dell.

• Cooling Systems: If using high-power fans, we recommend installing the server in a dedicated
soundproof server room or cabinet to avoid noise disruptions in your work environment.

By following these steps, you can easily complete your high-end ThreadRipper or EPYC server hard-
ware purchases on eBay.
3.1. EXAMPLE CONFIGURATIONS 29

3.1.4 A High-End DDR5 Configuration

Another high-end configuration has AMD’s Ryzen 9 7950X3D, DDR5 memory, and NVIDIA’s RTX 4090.
It is designed to provide exceptional performance for demanding tasks like deep learning, 3D render-
ing, gaming, and content creation. Below is the detailed configuration and an analysis of why each
component is suited for these high-performance tasks.

3.1.5 Configuration and Analysis

1. Processor (CPU): AMD Ryzen 9 7950X3D
• 16 cores, 32 threads
• Base frequency: 4.2 GHz, Max boost frequency: 5.7 GHz
• TDP: 120W
• 3D V-Cache technology for enhanced gaming and compute performance
• Architecture: Zen 4
Why it suits high-end performance: The AMD Ryzen 9 7950X3D combines high core count and
clock speed with AMD’s 3D V-Cache technology, which significantly enhances cache memory. This
boosts performance in memory-bound tasks like gaming, rendering, and certain deep-learning models.
The processor’s 16 cores and 32 threads make it highly capable of parallel processing, making it ideal
for handling multiple demanding tasks simultaneously. Its high single-core performance also benefits
tasks like gaming and workloads that depend on fast clock speeds.
Or,
1. Processor (CPU): AMD Ryzen 9 9950X
• 16 cores, 32 threads
• Base frequency: 4.4 GHz, Max boost frequency: 5.9 GHz
• TDP: 170W
• Supports PCIe 5.0 and DDR5 memory
• Architecture: Zen 5
Why it suits high-end performance: The AMD Ryzen 9 9950X combines high core count and clock
speed with support for the latest PCIe 5.0 and DDR5 memory technologies. This delivers superior
performance in memory-intensive tasks and faster data processing. With 16 cores and 32 threads, it
excels at parallel processing, making it perfect for demanding tasks like rendering and AI workloads.
Its AI optimizations and advanced architecture make it ideal for gaming and productivity, benefiting
both single-core and multi-core performance.
2. Graphics Card (GPU): NVIDIA GeForce RTX 4090
• Memory: 24 GB GDDR6X
• CUDA Cores: 16,384
• Tensor Cores: 512
• Memory Bandwidth: 1,008 GB/s
• Supports 8K resolution, ray tracing (RTX), and DLSS 3.0
Why it suits high-end performance: The NVIDIA RTX 4090 is the most powerful GPU available
in 2022, offering unparalleled performance for tasks such as deep learning, 3D rendering, and high-
end gaming. The 24 GB GDDR6X memory allows the handling of large datasets and complex models
without bottlenecks. With 16,384 CUDA cores and 512 Tensor cores, the RTX 4090 excels in parallel
computing tasks, especially in deep learning where massive matrix operations and tensor calculations
are needed. The advanced ray tracing and DLSS 3.0 technologies improve graphical fidelity and per-
30 CHAPTER 3. CHOOSING COMPUTER HARDWARE FOR PROGRAMMING AND ML

formance in games and visual simulations. The RTX 4090 is ideal for anyone requiring top-tier GPU
performance for AI, creative, or gaming workloads.
3. Memory (RAM): 96 GB DDR5
• Type: DDR5
• Frequency: 5200 MHz or slightly higher(up to 6000 MHz)
• Configuration: 2 x 48 GB modules
Why it suits high-end performance: Although DDR5 offers higher bandwidth and improved effi-
ciency over DDR4, it operates at slightly lower memory frequencies. The frequency might not reach its
full potential due to DDR5’s initial adoption phase, but the increased memory capacity—96 GB—more
than compensates for this, allowing users to work with large datasets and multitask efficiently. This
configuration is ideal for deep learning, large-scale simulations, and video editing, where vast amounts
of data must be processed simultaneously. The 96 GB capacity is future-proof, offering ample head-
room for memory-intensive applications.
4. Motherboard: B650/X670 Chipset
• Supports PCIe 5.0 (GPU slot)
• Supports overclocking
• Supports high-speed M.2 SSDs
Why it suits deep learning: The B650 and X670 chipsets provide PCIe 5.0 support, which is es-
sential for maximizing the performance of next-generation GPUs and NVMe SSDs used in deep learn-
ing. These motherboards offer enhanced memory speed, overclocking capabilities, and support for
high-bandwidth components, ensuring optimal performance for large datasets and compute-intensive
tasks. The B650 offers a more affordable option with essential features, while the X670 provides ad-
ditional PCIe lanes and connectivity options, making it a more robust choice for demanding deep
learning environments.
5. Storage (SSD): 4TB NVMe SSD
• Read speed: ∼ 7000 MB/s
• Write speed: ∼ 6800 MB/s
• Interface: PCIe 4.0
Why it suits high-end performance: The 4TB NVMe SSD offers fast read and write speeds, signifi-
cantly enhancing system responsiveness and reducing load times for large files and applications. This
is especially important in deep learning and video editing tasks where large datasets and files need to
be accessed and processed frequently. PCIe 4.0 support allows even faster data transfer rates, further
reducing bottlenecks in data-heavy workflows.
6. Storage (HDD): 20TB SATA HDD
• 7200 RPM, 256 MB cache
• Massive storage capacity
Why it suits high-end performance: The 20TB HDD provides an enormous amount of storage for
archival data, backups, and large datasets that do not require frequent access. While not as fast as
SSDs, the large capacity of the HDD is essential for long-term data storage in applications like video
editing, deep learning, and content creation, where raw data, project files, and backup images can
consume significant space.
7. Power Supply: 1200W 80 PLUS Platinum Certified PSU
• Provides ample power for high-end GPU and CPU
• Efficiency ensures stable performance under heavy loads
Why it suits high-end performance: A 1200W power supply ensures sufficient and stable power
3.2. HARDWARE CONSIDERATIONS FOR PROGRAMMING 31

delivery for the power-hungry RTX 4090 and Ryzen 9 7950X3D, especially during overclocking or peak
loads. The 80 PLUS Platinum certification guarantees high efficiency, reducing power waste and en-
suring reliability during prolonged high-load operations, which is critical for tasks like deep learning
and rendering that require long periods of uninterrupted performance.
8. Case: Full Tower Case
• Supports excellent airflow and multiple cooling solutions
• Ample space for large components
Why it suits high-end performance: A full tower case is essential for housing large components
like the RTX 4090, and it provides space for advanced cooling systems such as liquid cooling. Given
the high power consumption and heat generation of this configuration, efficient cooling is crucial to
prevent thermal throttling and ensure long-term stability during extended workloads.

3.2 Hardware Considerations for Programming

When working on general programming tasks, the hardware requirements are relatively modest com-
pared to machine learning or deep learning workloads. However, ensuring that you have appropriate
resources is still crucial for efficient development.

3.2.1 Processor (CPU)

For most programming tasks, a modern multi-core processor is sufficient. Compiling code and run-
ning applications will benefit from higher clock speeds and more cores, especially in multi-threaded
programming environments. However, a balance should be struck between power and cost based on
the complexity of your development needs.

3.2.2 Memory (RAM)

RAM is another critical factor for programming. While typical tasks may not be extremely memory-
intensive, having at least 16 GB of RAM is recommended to avoid slowdowns due to memory paging,
especially when running multiple applications or virtual machines.

3.2.3 Storage

Fast storage is essential for reducing load times when working with large files or compiling code.
Solid-state drives (SSDs) are highly recommended over traditional hard disk drives (HDDs) to ensure
faster data access and overall system responsiveness.

3.3 Hardware for Machine Learning and Deep Learning

Machine learning and deep learning tasks require considerably more powerful hardware due to the
scale and complexity of the operations involved.
32 CHAPTER 3. CHOOSING COMPUTER HARDWARE FOR PROGRAMMING AND ML

3.3.1 Processor (CPU)

While the CPU remains important for machine learning workflows, particularly for data preprocessing,
it plays a secondary role compared to the GPU in deep learning tasks. A high-end CPU, such as AMD’s
Ryzen or Intel’s i9 series, with multiple cores and high thread counts, is recommended to handle parallel
data pipelines effectively.

3.3.2 Graphics Processing Unit (GPU)

The choice of GPU is critical for deep learning due to its ability to handle parallel computations effi-
ciently. While NVIDIA GPUs with CUDA support remain widely used, there are now viable alternatives
from Apple and AMD, offering diverse options for different users.

NVIDIA GPUs

NVIDIA continues to be a dominant player in deep learning, with their CUDA framework and GPUs
such as the RTX series for consumer use and the A100 for enterprise-level tasks. These GPUs excel in
handling large datasets and complex model training. Models like the RTX 4090, with 24 GB of memory,
or enterprise-grade cards with even more VRAM, are ideal for heavy workloads.

Apple’s Metal Performance Shaders (MPS)

For users with modern Apple Silicon Macs, Apple’s Metal Performance Shaders (MPS) offer an in-
tegrated solution for GPU acceleration in deep learning. MPS support is built into frameworks such
as PyTorch, enabling accelerated model training directly on Apple’s M1, M2, and M3 chips. The uni-
fied memory architecture in Apple Silicon allows Apple GPUs to access the entire system’s memory,
making it an attractive option for local development without the need for external GPUs.

AMD ROCm

AMD’s ROCm (Radeon Open Compute) platform is gaining traction as a strong competitor to CUDA,
particularly with support for PyTorch, TensorFlow, and JAX. AMD’s recent GPUs, including the Radeon
RX 7900 XTX and the MI250 series, are optimized for deep learning tasks. ROCm enables high-
performance computing and offers alternatives for users looking for non-NVIDIA options, especially
in Linux environments.

Memory Considerations

Regardless of the GPU brand, selecting a GPU with enough VRAM is critical. GPUs with 16 GB to 24
GB of memory, such as NVIDIA RTX cards and AMD’s Radeon Pro models, or Apple Silicon Macs with
more than 32 GB of RAM are recommended to prevent memory bottlenecks during training.
Each of these platforms has its strengths, allowing users to choose based on their budget, hard-
ware preferences, and compatibility with their development environments.

3.3.3 Memory (RAM)

RAM requirements for machine learning vary depending on the size of the dataset and the complexity
of the models being trained. A minimum of 32 GB of RAM is generally recommended for most deep
3.4. MAKING INFORMED DECISIONS 33

learning tasks, with 64 GB or more being preferable for larger datasets and more complex model
architectures.

3.3.4 Storage
Deep learning tasks can involve large datasets that require fast access times. NVMe SSDs are ideal
for this, providing high-speed data retrieval necessary for fast iteration and model training.

3.3.5 Other Considerations

For distributed training or working with very large datasets, systems with multiple GPUs or access
to a dedicated server may be necessary. Additionally, cloud-based solutions such as AWS or Google
Cloud can be explored as scalable options for handling massive workloads that exceed local hardware
capabilities.

3.4 Making Informed Decisions

Choosing the right hardware for your specific needs depends on the type of tasks you expect to per-
form. While general programming can be accomplished on relatively modest systems, machine learn-
ing, and deep learning require significantly more powerful hardware, particularly in terms of GPUs and
memory capacity. The goal of this chapter is to help you identify the right balance of components to
ensure smooth development and efficient training workflows.
34 CHAPTER 3. CHOOSING COMPUTER HARDWARE FOR PROGRAMMING AND ML
Chapter 4

Setting Up Your Development

Environment

Before embarking on any task, having the proper tools is crucial for success. In the realm of software
development, setting up a proper development environment is the first critical step. With the right
setup, developers can streamline their workflow, reduce errors, and focus on producing high-quality
code. This chapter will guide you through the necessary steps to prepare your development environ-
ment, ensuring you are equipped to work efficiently with Python.

4.1 Installing Python

In this section, we will begin by setting up Python on your machine. Python is a versatile and widely
used programming language, and installing it correctly is essential for any Python development. The
following steps will guide you through downloading, installing, and verifying the Python installation on
different operating systems.

4.1.1 Downloading Python

To download the latest version of Python, visit the official Python website at https://www.python.org.
Navigate to the Downloads section, where you can choose the appropriate version for your operating
system (Windows, macOS, or Linux). It is recommended to download the latest stable release for
better compatibility with modern libraries and tools.

4.1.2 Installing on Windows/Mac/Linux

Once you have downloaded the Python installer, follow these instructions for installing Python on your
system:

• Windows: Run the installer and ensure the option "Add Python to PATH" is checked before con-
tinuing with the installation. This will allow you to run Python from the command line.

• macOS: macOS usually comes with Python pre-installed, but it may be an older version. To install
the latest version, you can use a package manager like Homebrew (brew install python) or
download it from the Python website.

35
36 CHAPTER 4. SETTING UP YOUR DEVELOPMENT ENVIRONMENT

• Linux: Most Linux distributions include Python by default, but if it’s not present, you can install it
manually using your package manager, such as apt for Ubuntu (sudo apt install python3) or
dnf for Fedora.

4.1.3 Verifying the Installation

After installing Python, it is crucial to verify the installation. Open a terminal or command prompt and
type the following command:

python --version

If the installation is successful, the terminal will display the installed Python version.
 
Python 3.11.3
 

Additionally, you can check whether the Python package installer, pip, is installed by typing:

pip --version

Note: If you are installing a newer version of Python 3.x, pip is usually installed automatically along
with it.
Once both versions are displayed, your Python installation is complete, and you are ready to begin
coding!
 
pip 23.3.2 from C:\Users\user\AppData\Local\Programs\Python\Python311\Lib\site-packages\pip (
python 3.11)
 

4.2 Setting Up a Virtual Environment

In this section, we will explore the significance of virtual environments in Python development and
cover two popular ways to create and manage virtual environments: using venv and conda. Virtual
environments allow you to isolate project dependencies and avoid conflicts between different versions
of libraries.

4.2.1 Importance of Virtual Environments

A virtual environment is an isolated environment that contains its installation directories and libraries,
separate from the global Python installation. This is essential when working on multiple projects that
require different versions of Python packages. Virtual environments enable you to:

• Avoid dependency conflicts between projects.

• Easily manage and track project-specific packages.

• Test code in different environments without affecting the system-wide installation.

4.3. INSTALLING ESSENTIAL PACKAGES 37

4.2.2 Creating a Virtual Environment with conda

If you are using Anaconda or Miniconda, conda provides a powerful way to manage virtual environ-
ments. To create a virtual environment with conda, follow these steps:

1. Open your terminal or Anaconda Prompt.

2. Run the following command to create a new virtual environment with the desired Python version:

conda create --name myenv python=3.x

3. To activate the environment, run:

conda activate myenv

4. To deactivate the environment, run:

conda deactivate

4.2.3 Activating/Deactivating a Virtual Environment

To activate or deactivate conda virtual environments:

• Activate: conda activate myenv

• Deactivate: conda deactivate

Note: After activating the virtual environment, your terminal prompt will display the environment
name in parentheses, e.g., (myenv), indicating that the environment is active.

4.3 Installing Essential Packages

In this section, we will discuss how to install Python packages using pip, introduce some commonly
used packages, and provide tips on managing dependencies effectively. Packages are essential tools
that help extend the functionality of Python and simplify various programming tasks.

4.3.1 Using pip to Install Packages

pip is the standard package manager for Python, used to install and manage libraries that are not part
of the Python standard library. To install a package, use the following command:

pip install package_name

For example, to install numpy in a specific conda environment, follow these steps:
1. First, activate the environment where you want to install numpy by running:

conda activate myenv

2. Once the environment is activated, install numpy within that environment by running:

pip install numpy

38 CHAPTER 4. SETTING UP YOUR DEVELOPMENT ENVIRONMENT

This ensures that numpy is installed specifically in the activated environment.

To install multiple packages at once, use:

pip install numpy pandas matplotlib

To check if a package is installed or to see the installed version, use:

pip show package_name

To upgrade an already installed package to the latest version, use:

pip install --upgrade package_name

4.3.2 Commonly Used Packages (e.g., numpy, pandas, matplotlib)

There are many widely used Python packages, including:

• numpy: A powerful library for numerical computations [36].

• pandas: A data manipulation and analysis library [102].

• matplotlib: A plotting library for visualizations [41].

• scikit-learn: A machine learning library for data mining and analysis [78].

• requests: A simple HTTP library for making web requests.

• tqdm: A fast, extensible progress bar for loops and command-line applications.

4.3.3 Installing Special Packages - PyTorch and CUDA

Note: If you do not fully understand what CUDA is or do not need GPU acceleration at the moment, you
can skip this section and simply install the CPU version of PyTorch using the following command:

pip install torch torchvision torchaudio

PyTorch is a deep learning framework widely used in artificial intelligence and machine learning
tasks [76]. PyTorch supports both CPU and GPU computations, leveraging CUDA for GPU accelera-
tion. To utilize GPU for faster training and inference, it is essential to install the appropriate version
of PyTorch that is compatible with CUDA. Below is an introduction to CUDA and the steps to install a
CUDA-enabled PyTorch version.

Introduction to CUDA

CUDA (Compute Unified Device Architecture) is a parallel computing platform and API developed by
NVIDIA that enables developers to use GPUs for high-performance computations. For tasks such as
deep learning, where large-scale computations are required, GPU acceleration can significantly speed
up model training and inference. To allow PyTorch to take advantage of CUDA, the correct version of
the CUDA toolkit and a compatible version of PyTorch must be installed.
 4.3. INSTALLING ESSENTIAL PACKAGES 39

Installing a CUDA-Enabled PyTorch

Follow these steps to install PyTorch with CUDA support:

1. Ensure that your system has the NVIDIA GPU driver and the appropriate version of the CUDA
toolkit installed. You can check the CUDA version on your system using the command nvidia-smi.

2. Visit the official PyTorch website (https://pytorch.org/get-started/locally/) and select the

proper options for your operating system, a package manager (e.g., pip or conda), and the version
of CUDA that matches your system configuration.

3. For instance, if you want to install PyTorch with CUDA 11.8 on Windows using pip, you can follow
the selection process and copy the generated command below into your Conda environment for
execution.

Figure 4.1: PyTorch installation guide for Windows using Pip with CUDA 11.8, showing the command
to install PyTorch, torchvision, and torchaudio.

4. If the CUDA toolkit is not yet installed on your system, follow the instructions on the NVIDIA
website to download and install the correct version.

Verifying PyTorch CUDA Support

After installation, you can verify whether PyTorch detects CUDA support by running the following
Python command in your conda environment:

1 import torch
2 print(torch.cuda.is_available()) # Returns True if CUDA is available

By installing PyTorch with CUDA support, you can take full advantage of the computational power
of GPUs, dramatically improving the performance of deep learning models, especially when dealing
with large datasets and complex architectures.

4.3.4 Installing Special Packages - TensorFlow and CUDA

Note: If you do not fully understand what CUDA is or do not need GPU acceleration at the moment, you
can skip this section and simply install the CPU version of TensorFlow using the following command:
40 CHAPTER 4. SETTING UP YOUR DEVELOPMENT ENVIRONMENT

pip install tensorflow

To use TensorFlow [1] with GPU acceleration, you will need to install the correct version of Ten-
sorFlow that is compatible with your system’s CUDA version. TensorFlow leverages NVIDIA’s CUDA
framework for GPU computation, which can greatly accelerate the performance of deep learning mod-
els.
Here are the steps to install TensorFlow with CUDA support:

• First, ensure that you have a compatible version of CUDA and cuDNN installed. TensorFlow
supports specific versions of CUDA and cuDNN, so check TensorFlow’s compatibility chart to
match the correct versions.

• Next, install the TensorFlow GPU version via pip:

pip install tensorflow-gpu

• After installation, verify that TensorFlow can access the GPU by running the following Python
script:

1 import tensorflow as tf
2 print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU')))

If the output shows the number of available GPUs, the installation was successful and Tensor-
Flow is ready to use the GPU for computations.

Num GPUs Available: 0

Make sure you also have the necessary NVIDIA drivers installed on your system for CUDA to func-
tion properly. Additionally, it’s recommended to use a virtual environment to manage package depen-
dencies effectively.

4.3.5 Managing Dependencies

Managing multiple packages and their versions is crucial for project stability. Some best practices
include:

1. Using a requirements.txt file: List the required packages and versions in this file.
 
// Basic version
numpy
tqdm
opencv-python

// Specifying a minimum version

gradio>=4.21.0
matplotlib>=3.2.2
 

Once you’ve listed your required packages in the requirements.txt file, you can install all the
packages at once with the following command:
4.4. SETTING UP AN INTEGRATED DEVELOPMENT ENVIRONMENT (IDE) 41

 
pip install -r requirements.txt
 

2. Specifying version numbers: Ensure correct package versions in the requirements.txt file to
avoid issues from updates.

3. Using virtual environments: Isolate your project’s dependencies from the global environment.

4.4 Setting Up an Integrated Development Environment (IDE)

In this section, we will explore the differences between text editors and integrated development en-
vironments (IDEs), and discuss how to set up and configure a popular IDE for Python development.
Having the right development environment is crucial for improving productivity, organizing code, and
simplifying debugging processes.

4.4.1 Introduction to Popular IDEs (e.g., PyCharm, VSCode)

There are two primary types of tools for writing and managing code: text editors and IDEs. Both serve
the purpose of editing code, but they differ in functionality and the level of integration.

• Text Editors: Text editors are generally simpler and lighter, focusing on writing and editing text,
with fewer built-in features. Some popular text editors include:

– Vim: A highly customizable, keyboard-driven text editor favored by developers for its effi-
ciency.
– Notepad++: A free text editor for Windows that supports syntax highlighting and other basic
features but lacks integrated debugging or project management.
– VSCode (Visual Studio Code): A highly extensible text editor that, with the right extensions,
can function similarly to an IDE. It supports syntax highlighting, debugging, version control,
and more.

• IDEs: Integrated Development Environments come with a full set of tools for coding, debugging,
testing, and managing projects all in one place.

– PyCharm: A powerful IDE specifically designed for Python development. PyCharm provides
tools like code completion, debugging, refactoring, and testing built into one package, mak-
ing it ideal for larger, more complex projects.

4.4.2 Setting Up and Configuring Your IDE

Once you’ve selected the right tool for your workflow, the next step is setting up your IDE or text editor.
Below, we’ll outline how to configure VSCode and PyCharm.

• Setting Up VSCode:

1. Download and install VSCode.

2. Install the Python extension from the Extensions Marketplace.
3. Set the correct Python interpreter via the command palette (Ctrl+Shift+P).
42 CHAPTER 4. SETTING UP YOUR DEVELOPMENT ENVIRONMENT

4. Install additional extensions like Pylint and Black for linting and code formatting.

• Setting Up PyCharm:

1. Download and install PyCharm.

2. Set up a new Python project and configure the Python interpreter.
3. Customize settings for code style, Git integration, and the integrated terminal.
4. Use PyCharm’s powerful debugging tools to step through your code and troubleshoot is-
sues.

Proper configuration of your IDE or text editor can significantly improve your productivity and help
you focus on writing better code.

4.4.3 Recommended VSCode Extensions

Here are some useful extensions for VSCode that can enhance your Python development workflow
and help with specific tasks:

• JSON Crack: A handy tool for visualizing JSON structures. This extension allows you to explore
JSON data in a graphical format, making it easier to understand complex nested structures.

• Rainbow CSV: This extension highlights columns in CSV files, making it easier to recognize and
differentiate columns when working with data. It’s particularly helpful when dealing with large
datasets or unformatted CSV files.

• Copilot: A powerful AI-driven extension developed by GitHub. Copilot assists by providing intel-
ligent code suggestions, auto-completion, and even writing entire blocks of code based on your
prompts, greatly improving coding speed and accuracy.

• CodeSnap: A simple but effective extension that allows you to take beautiful screenshots of
your code snippets directly from VSCode. It includes customization options like background
color and padding to enhance readability and aesthetics.
 Chapter 5

Introduction to Python Programming

In this chapter, we will start by writing a simple Python program to print a message, “Hello, World!”
This is the first step in learning any programming language and will help you understand the basics of
Python syntax.

5.1 Hello World

In this section, we will begin with the most basic Python program by printing a string to the screen.

5.1.1 Hello World — Printing a String

First, let’s look at a very simple program that prints “Hello, World!” to the screen.

1 print("Hello, World!")

When you run this code, the output on your screen will be:
 
Hello, World!
 
This program is very simple. It uses the “print” function to display the text inside the parentheses
on the screen. This is your first Python program.

5.1.2 Hello World — Defining a Function

Next, we can place the above code inside a function. A function is like a small tool that you can use
whenever you need to perform a specific task.

1 def hello_world():
2 print("Hello, World!")

Now, if we want to display “Hello, World!” we just need to call this function:

1 hello_world()

When you run this code, the output on your screen will be:
 
Hello, World!
 

43
 44 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

Here is the complete code:

1 def hello_world():
2 print("Hello, World!")
3

4 hello_world()

5.1.3 Hello World — Using if __name__ == "__main__"

Next, let’s discuss a slightly more complex concept. Suppose you have two Python files: one called
hw.py and another called test.py. Let’s first look at the hw.py file:

1 def hello_world():
2 print("Hello, World!")
3

4 if __name__ == "__main__":
5 hello_world()

Here’s what happens:

When you run the hw.py file directly, Python will execute the hello_world() function, and the output
on your screen will be:
 
Hello, World!
 
Now, suppose you want to use the hello_world function from hw.py in another file, test.py. You
can do this as follows:

1 import hw
2

3 hw.hello_world()

When you run test.py, the output on your screen will be:
 
Hello, World!
 
However, if you do not want the code in hw.py to run automatically when it is imported into another
file, but only when it is run directly, then if __name__ == "__main__" is very useful. This ensures that
hello_world() is only executed when you run hw.py directly; if you import it into main.py, the code will
not run unless you explicitly call it in test.py.
This is the purpose of if __name__ == "__main__" — it prevents code from running when it is not
supposed to, giving you better control over the behavior of your program.
In debugging a program that consists of multiple source files, using the if __name__ == "__main__"
statement can help you debug more effectively. Specifically, when your project includes multiple mod-
ules or script files, each file may have its functionality, logic, and interfaces. When you want to debug
a specific module independently, you can add if __name__ == "__main__" to that module and write
some modular test code or invoke functions within that module underneath it. This not only helps in
verifying the module’s independence but also ensures that each part can function correctly on its own
when integrated with other modules, thereby improving debugging efficiency and program reliability.
On Windows, if you want to use multi-threading, you must also wrap the main program in the if
__name__ == "__main__" construct. This is because, on Windows, when using multi-threading or
 5.2. DATA TYPES IN PYTHON 45

multi-processing modules (such as threading or multiprocessing), child processes will reload the
main program. Without this safeguard, the main program might be executed multiple times, leading
to the creation of new processes in a loop, which could cause infinite recursion or other unexpected
behavior. Therefore, when writing multi-threaded programs, especially on Windows, it’s crucial to place
the main program inside the if __name__ == "__main__" block to avoid such issues.

5.2 Data Types in Python

Python supports several built-in data types, which can be broadly categorized into numbers, strings,
lists, tuples, dictionaries, and sets. Understanding these types is essential for managing data effec-
tively in Python.

5.2.1 Numbers
Numbers in Python include integers, floats (decimal numbers), and complex numbers. Python sup-
ports standard arithmetic operations on numbers such as addition, subtraction, multiplication, and
division.

1 x = 10 # integer
2 y = 3.14 # float
3 z = 1 + 2j # complex number

Python automatically performs type conversion (implicit casting) when you perform operations
between different types of numbers. For example, if you add an integer and a float, Python will au-
tomatically convert the integer to a float, ensuring that the result is also a float. Similarly, operations
between floats and complex numbers will result in a complex number.

Example 1: Integer and Float Addition

When you add an integer and a float, the result is a float because Python promotes the integer to a
float to avoid losing precision.

1 a = 10 # integer
2 b = 2.5 # float
3 result = a + b
4 print(result)
5 print(type(result))

Output:

12.5
<class 'float'>

Example 2: Float and Complex Number Addition

When adding a float and a complex number, Python automatically converts the float to a complex
number, preserving the real and imaginary parts.
 46 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

1 c = 3.14 # float
2 d = 2 + 3j # complex number
3 result = c + d
4 print(result)
5 print(type(result))

Output:

(5.14+3j)
<class 'complex'>

Example 3: Division of Integers Results in a Float

Even when dividing two integers, the result will always be a float in Python 3.x. This ensures that
division always returns a precise result, avoiding truncation.

1 e = 10
2 f = 3
3 result = e / f
4 print(result)
5 print(type(result))

Output:

3.3333333333333335
<class 'float'>

Example 4: Integer Division Using //

If you want to perform integer division (where the result is an integer and truncates the decimal part),
you can use the ‘//‘ operator.

1 g = 10
2 h = 3
3 result = g // h
4 print(result)
5 print(type(result))

Output:

3
<class 'int'>

Example 5: Modulus and Power Operations

Python also supports modulus and power operations on numbers:

1 i = 10
2 j = 3
3
 5.2. DATA TYPES IN PYTHON 47

4 # Modulus: Remainder of division

5 modulus_result = i % j
6 print(modulus_result)
7

8 # Power: Raising a number to a power

9 power_result = i ** j
10 print(power_result)

Output:
1
1000

5.2.2 Strings
Strings are sequences of characters. They can be created by enclosing text in either single or double
quotes.
1 greeting = "Hello, Python!"
2 name = 'Alice'

Common String Methods

Python provides several built-in methods to manipulate strings. For example:

1 text = "hello world"
2 print(text.upper())
3 print(text.replace("world", "Python"))

Output:
HELLO WORLD
hello Python

String Formatting

You can format strings using various methods, including f-strings, the format method, or using the old
% operator.
1 name = "Alice"
2 age = 25
3 print(f"My name is {name} and I am {age} years old.") # f-string
4 print("My name is {} and I am {} years old.".format(name, age)) # .format()
5 print("My name is %s and I am %d years old." % (name, age)) # % operator
6 print("My name is " + str(name) + "and I am " + str(age) + "years old.") # string concatenation

Output:
My name is Alice and I am 25 years old.
My name is Alice and I am 25 years old.
My name is Alice and I am 25 years old.
My name is Alice and I am 25 years old.
 48 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

5.3 Lists
Lists are ordered collections of items in Python. They are mutable, which means you can change their
content without creating a new list. Lists can hold items of different data types, including other lists.

1 # Creating a list
2 fruits = ["apple", "banana", "cherry"]
3 print(fruits[0])
4

5 # Accessing list elements

6 print(fruits[1])
7 print(fruits[-1])
8

9 # Slicing lists
10 print(fruits[1:3])
11

12 # Unpack lists
13 print(*fruits)

Output:

apple
banana
cherry
['banana', 'cherry']
banana cherry

5.3.1 Common List Methods

Python lists come with several useful methods for manipulating their content:

1 # Creating a list
2 fruits = ["apple", "banana", "cherry"]
3 print("Original list:", fruits)
4

5 # Adding an item to the list

6 fruits.append("orange") # Adds 'orange' to the end of the list
7 print("After append:", fruits)
8

9 # Inserting an item at a specific position

10 fruits.insert(1, "blueberry") # Inserts 'blueberry' at index 1
11 print("After insert:", fruits)
12

13 # Removing an item by value

14 fruits.remove("banana") # Removes the first occurrence of 'banana'
15 print("After remove:", fruits)
16

17 # Removing an item by index

18 del fruits[0] # Removes the item at index 0 ('apple')
19 print("After delete:", fruits)
 5.4. TUPLES 49

20

21 # Sorting the list

22 fruits.sort() # Sorts the list in alphabetical order
23 print("After sort:", fruits)
24

25 # Reversing the list

26 fruits.reverse() # Reverses the order of the list
27 print("After reverse:", fruits)
28

29 # Copying the list

30 new_fruits = fruits.copy() # Creates a shallow copy of the list
31 print("Copied list:", new_fruits)

Output:
Original list: ['apple', 'banana', 'cherry']
After append: ['apple', 'banana', 'cherry', 'orange']
After insert: ['apple', 'blueberry', 'banana', 'cherry', 'orange']
After remove: ['apple', 'blueberry', 'cherry', 'orange']
After delete: ['blueberry', 'cherry', 'orange']
After sort: ['blueberry', 'cherry', 'orange']
After reverse: ['orange', 'cherry', 'blueberry']
Copied list: ['orange', 'cherry', 'blueberry']

5.3.2 Nested Lists

Lists can contain other lists, which allows for the creation of more complex data structures.
1 # Creating a nested list
2 matrix = [
3 [1, 2, 3],
4 [4, 5, 6],
5 [7, 8, 9]
6 ]
7

8 # Accessing elements in a nested list

9 # matrix[row][column]
10 print(matrix[0][1]) # Output: 2
11 print(matrix[1]) # Output: [4, 5, 6]

Output:
2
[4, 5, 6]

5.4 Tuples
Tuples are immutable sequences in Python, meaning once you create a tuple, you cannot modify its
elements. They are often used to group related data together and can be of mixed data types. Tuples
are defined using parentheses ‘()‘.
 50 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

1 # Creating a tuple
2 coordinates = (10, 20)
3 print(coordinates[0]) # Prints the first element
4 print(coordinates[1]) # Prints the second element
5

6 # Tuples can contain different types of data

7 mixed_tuple = (1, "apple", 3.14, [1, 2, 3])
8 print(mixed_tuple) # Prints the entire tuple
9

10 # Nested tuples
11 nested_tuple = (1, (2, 3), (4, 5))
12 print(nested_tuple[1]) # Prints the nested tuple at index 1
13 print(nested_tuple[1][0]) # Prints the first element of the nested tuple at index 1
14

15 # Tuple unpacking
16 a, b, c = (10, 20, 30)
17 print(a) # Prints the value of a
18 print(b) # Prints the value of b
19 print(c) # Prints the value of c
20

21 # Concatenating tuples
22 tuple1 = (1, 2, 3)
23 tuple2 = (4, 5, 6)
24 combined = tuple1 + tuple2
25 print(combined) # Prints the concatenated tuple
26

27 # Repeating tuples
28 repeated = tuple1 * 3
29 print(repeated) # Prints the repeated tuple
30

31 # Checking membership
32 print(2 in tuple1) # Checks if 2 is in tuple1
33 print(7 in tuple1) # Checks if 7 is in tuple1

Output:

10
20
(1, 'apple', 3.14, [1, 2, 3])
(2, 3)
2
10
20
30
(1, 2, 3, 4, 5, 6)
(1, 2, 3, 1, 2, 3, 1, 2, 3)
True
False
 5.5. DICTIONARIES 51

5.5 Dictionaries

Dictionaries are collections of key-value pairs. They allow you to store data that is associated with a
unique key. Dictionaries are defined using curly braces ‘‘.

1 # Creating a dictionary
2 person = {"name": "Alice", "age": 25}
3 print(person["name"]) # Prints the value associated with the key 'name'
4 print(person["age"]) # Prints the value associated with the key 'age'
5

6 # Adding a new key-value pair

7 person["email"] = "[email protected]"
8 print(person) # Prints the updated dictionary
9

10 # Updating an existing value

11 person["age"] = 26
12 print(person) # Prints the dictionary with the updated age
13

14 # Removing a key-value pair

15 del person["email"]
16 print(person) # Prints the dictionary after removing the 'email' key
17

18 # Accessing keys and values

19 print(person.keys()) # Prints all keys in the dictionary
20 print(person.values()) # Prints all values in the dictionary
21

22 # Checking if a key exists

23 print("name" in person) # Checks if 'name' is a key in the dictionary
24 print("email" in person) # Checks if 'email' is a key in the dictionary
25

26 # Using the get method

27 print(person.get("name")) # Safely retrieves the value for 'name'
28 print(person.get("phone", "Not Available")) # Returns default value if 'phone' key does not exist

Output:

Alice
25
{'name': 'Alice', 'age': 25, 'email': '[email protected]'}
{'name': 'Alice', 'age': 26, 'email': '[email protected]'}
{'name': 'Alice', 'age': 26}
dict_keys(['name', 'age'])
dict_values(['Alice', 26])
True
False
Alice
Not Available
 52 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

5.6 Sets
Sets are unordered collections of unique elements. They are useful when you want to store unique
values and perform operations like union, intersection, and difference. Sets are defined using curly
braces ‘‘.
1 # Creating a set
2 my_set = {1, 2, 3, 3, 4}
3 print(my_set) # Prints the set, automatically removing duplicates
4

5 # Adding elements to the set

6 my_set.add(5)
7 print(my_set) # Prints the set after adding 5
8

9 # Removing elements from the set

10 my_set.remove(2)
11 print(my_set) # Prints the set after removing 2
12

13 # Checking membership
14 print(3 in my_set) # Checks if 3 is in the set
15 print(2 in my_set) # Checks if 2 is in the set
16

17 # Set operations
18 set1 = {1, 2, 3}
19 set2 = {3, 4, 5}
20

21 # Union of sets
22 union_set = set1 | set2
23 print(union_set) # Prints the union of set1 and set2
24

25 # Intersection of sets
26 intersection_set = set1 & set2
27 print(intersection_set) # Prints the intersection of set1 and set2
28

29 # Difference of sets
30 difference_set = set1 - set2
31 print(difference_set) # Prints the difference between set1 and set2
32

33 # Symmetric difference of sets

34 symmetric_difference_set = set1 ^ set2
35 print(symmetric_difference_set) # Prints the symmetric difference between set1 and set2

Output:
{1, 2, 3, 4}
{1, 2, 3, 4, 5}
{1, 3, 4, 5}
True
False
{1, 2, 3, 4, 5}
{3}
 5.7. VARIABLES IN PYTHON 53

{1, 2}
{1, 2, 4, 5}

5.7 Variables in Python

Variables in Python are used to store data, and their values can change throughout the program.
Python does not require explicit variable declarations. Variables can be classified into global and local
types.

5.7.1 Global and Local Variables

Variables defined outside of functions are global variables, while those defined inside functions are
local variables. Global variables can be accessed from anywhere in the code, whereas local variables
are only accessible within the function where they are defined.

1 x = "global" # Global variable

2

3 def example():
4 x = "local" # Local variable
5 print(x)
6

7 example()
8 print(x)

Output:

local
global

5.7.2 Call by Object Reference

In Python, when passing arguments to functions, you are passing references to the objects, not copies
of the objects. This means that changes made to mutable objects inside a function will affect the
original object, while immutable objects will not be altered.

Mutable Objects

Mutable objects can be changed after their creation. Lists, dictionaries, and sets are examples of
mutable objects.

1 def modify_list(lst):
2 lst.append(4) # Modifies the original list
3

4 original_list = [1, 2, 3]
5 modify_list(original_list)
6 print(original_list)

Output:
 54 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

[1, 2, 3, 4]

Immutable Objects

Immutable objects cannot be changed after their creation. Integers, floats, strings, and tuples are
examples of immutable objects.

1 def modify_tuple(t):
2 t += (4,) # Creates a new tuple, does not modify the original tuple
3

4 original_tuple = (1, 2, 3)
5 modify_tuple(original_tuple)
6 print(original_tuple)

Output:

(1, 2, 3)

5.8 Floating-Point Precision Issues in Python

In Python, when working with floating-point numbers, you may encounter results that differ slightly
from what you expect. This occurs because of the way floating-point numbers are stored in a com-
puter, which can lead to precision issues. This problem is not unique to Python—many other program-
ming languages also experience similar behavior.

5.8.1 The Cause of Floating-Point Precision Issues

Computers represent floating-point numbers using the IEEE 754 standard, which stores numbers as
binary fractions. However, decimal numbers like 0.1 and 0.2 cannot be exactly represented in binary,
which leads to small rounding errors during storage and computation. For example, in Python, when
calculating 0.1 + 0.2, the result is 0.30000000000000004 instead of 0.3.

>>> 0.1 + 0.2

0.30000000000000004

5.8.2 Which Programming Languages Have Similar Issues?

This floating-point precision problem occurs in many programming languages that also use the IEEE
754 standard, including but not limited to: JavaScript, Java, C, C++, Go, Ruby, and Swift.

5.8.3 The Real Impact of Floating-Point Operations

This precision issue can affect not only simple arithmetic operations but also common iteration oper-
ations. For example, when using code like np.arange(0.1, 0.4, 0.1), you might expect the output to
be 0.1, 0.2, and 0.3, but due to precision errors, the output could include 0.30000000000000004 and 0.4.
 5.8. FLOATING-POINT PRECISION ISSUES IN PYTHON 55

1 import numpy as np
2

3 for x in np.arange(0.1, 0.4, 0.1):

4 print(x)

Output:

0.1
0.2
0.30000000000000004
0.4

As seen in the example above, the accumulation of floating-point precision errors causes the result
to deviate from what you might expect, such as 0.3 being displayed as 0.30000000000000004.

5.8.4 How to Handle Floating-Point Precision in Python

To avoid these floating-point precision issues, Python provides the decimal module, which allows for
exact decimal arithmetic. This is especially useful in financial or scientific calculations. For example,
by using decimal.Decimal, you can get exact results without floating-point errors.

1 from decimal import Decimal

2

3 a = Decimal('0.1')
4 b = Decimal('0.2')
5 print(a + b)

Output:

0.3

5.8.5 Banker’s Rounding and Floating-Point Precision

One common issue arising from floating-point precision is related to rounding methods, such as
Banker’s Rounding. This rounding method, also known as round-half-to-even, helps to minimize cu-
mulative rounding errors. It rounds to the nearest value, with ties broken by rounding to the nearest
even number.
Python’s built-in ‘round()‘ function provides an example of Banker’s Rounding behavior. Consider
rounding 2.5 and 3.5 using Python’s ‘round()‘ function:

1 # Example of Banker's Rounding using Python's round() function

2

3 # Round 2.5 and 3.5 using Banker's rounding

4 print(round(2.5))
5 print(round(3.5))

Output:

2
4
 56 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

If you need traditional rounding where 0.5 always rounds up to the next integer, you can use the
‘decimal‘ module with the ‘ROUND_HALF_UP‘ method:

1 import decimal
2

3 decimal.getcontext().rounding = decimal.ROUND_HALF_UP
4

5 # Round 2.5 and 3.5 using traditional rounding

6 print(decimal.Decimal('2.5').quantize(decimal.Decimal('1')))
7 print(decimal.Decimal('3.5').quantize(decimal.Decimal('1')))

Output:

3
4

5.9 Basic Control Structures

5.9.1 Logical Operators: and, or, not

Logical operators in Python allow you to combine or invert conditions in your conditional statements.
The three main logical operators are and, or, and not.

and Operator:

The and operator is used to combine two or more conditions. It returns True only if all conditions are
true. If any condition is false, the entire expression evaluates to False.

1 # Example of the and operator

2 age = 25
3 income = 50000
4

5 if age > 18 and income > 30000:

6 print("You are eligible for a loan")
7 else:
8 print("You are not eligible for a loan")

Output:

You are eligible for a loan

In this example, both conditions (age > 18 and income > 30000) are true, so the program prints
"You are eligible for a loan."

or Operator:

The or operator is used to combine two or more conditions. It returns True if at least one of the
conditions is true. If all conditions are false, the expression evaluates to False.
 5.9. BASIC CONTROL STRUCTURES 57

1 # Example of the or operator

2 age = 17
3 has_parental_consent = True
4

5 if age > 18 or has_parental_consent:

6 print("You can apply for a driver's license")
7 else:
8 print("You cannot apply for a driver's license")

Output:

You can apply for a driver's license

In this case, even though the age is less than 18, the second condition (has_parental_consent) is
true, so the program prints "You can apply for a driver’s license."

not Operator:

The not operator is used to invert the result of a condition. If the condition is True, not makes it False,
and if the condition is False, not makes it True.

1 # Example of the not operator

2 is_raining = False
3

4 if not is_raining:
5 print("You don't need an umbrella")
6 else:
7 print("You need an umbrella")

Output:

You don't need an umbrella

In this example, since is_raining is False, the not operator inverts it to True, so the program prints
"You don’t need an umbrella."

5.9.2 Conditional Statements: if, elif, else

Conditional statements are used in Python to control the flow of a program based on certain condi-
tions. The most common conditional statements are if, elif, and else.
if statements execute a block of code if a specified condition is true. The elif keyword allows you
to check multiple expressions for True and execute a block of code as soon as one of the conditions
evaluates to True. The else keyword catches anything that isn’t caught by the preceding conditions.

1 # Example of if, elif, and else statements

2 x = 10
3

4 if x > 15:
5 print("x is greater than 15")
6 elif x == 10:
7 print("x is equal to 10")
 58 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

8 else:
9 print("x is less than 10")

Output:
x is equal to 10

In this example, the program checks if x is greater than 15, then checks if it is equal to 10. Since x
equals 10, the second block is executed, and the message "x is equal to 10" is printed.
if statements can also be nested, allowing for more complex logic:
1 # Nested if statements
2 y = 20
3

4 if y > 10:
5 if y < 30:
6 print("y is between 10 and 30")
7 else:
8 print("y is greater than or equal to 30")
9 else:
10 print("y is less than or equal to 10")

Output:
y is between 10 and 30

In this nested if statement example, Python first checks if y is greater than 10, and then within that
block, it checks whether y is less than 30.
Note: It is important to avoid using too many layers of nested if statements as it can make the code
difficult to read and maintain. In such cases, it is better to refactor the code by using functions or logical
operators like and and or.

5.9.3 Loops: for and while

Loops allow you to repeat a block of code multiple times. Python has two main types of loops: for
loops and while loops.

for Loop:

The for loop is used to iterate over a sequence (such as a list, tuple, dictionary, set, or string). It will
execute the block of code for each item in the sequence.
1 # Example of a for loop with list[str]
2 fruits = ["apple", "banana", "cherry"]
3

4 for fruit in fruits:

5 print(fruit)

Output:
apple
banana
cherry
 5.9. BASIC CONTROL STRUCTURES 59

In this example, the for loop iterates over the list numbers, printing each item in the list.
You can also use the range() function to loop through a sequence of numbers. The range() func-
tion generates a sequence of numbers, starting from 0 by default, and stops before a specified number.
You can also specify the start, stop, and step values to control the sequence.
1 # Using range() in a for loop
2 for i in range(5):
3 print(i)

Output:
0
1
2
3
4

In this example, range(5) generates a sequence from 0 to 4, and the loop iterates through each
value.

Specifying Start and Stop Values

You can also specify a starting point and an ending point for the range() function. The loop will start
from the specified start value and stop right before the specified end value.
1 # Using range() with start and stop values
2 for i in range(3, 8):
3 print(i)

Output:
3
4
5
6
7

Using a Step Value

The range() function also allows you to specify a step value, which determines the increment between
each number in the sequence.
1 # Using range() with a step value
2 for i in range(0, 10, 2):
3 print(i)

Output:
0
2
4
6
8
 60 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

Using Negative Step Values

You can also use negative step values to count downwards.

1 # Using range() to count backwards
2 for i in range(10, 0, -2):
3 print(i)

Output:
10
8
6
4
2

while Loop:

The while loop continues to execute a block of code as long as a given condition is True. Once the
condition becomes False, the loop stops.
1 # Example of a while loop
2 count = 0
3

4 while count < 5:

5 print(count)
6 count += 1

Output:
0
1
2
3
4

In this example, the while loop keeps executing as long as count is less than 5. The variable count
increments by 1 with each iteration until the condition is no longer true.

Breaking and Continuing in Loops:

The flow of loops in Python can be controlled using two important keywords: break and continue.

break: The break statement is used to exit the loop completely. Once the break statement is encoun-
tered, the program immediately stops executing the current loop and moves on to the next section of
code after the loop. This is useful when you want to terminate a loop early, based on a specific condi-
tion.
1 # Example of break
2 for i in range(10):
3 if i == 5:
4 break
5 print(i)
 5.9. BASIC CONTROL STRUCTURES 61

Output:

0
1
2
3
4

In this example, the loop prints the numbers from 0 to 4. When i equals 5, the break statement is
executed, and the loop is exited, preventing the numbers 5 through 9 from being printed.

continue: The continue statement is used to skip the current iteration of the loop and move directly
to the next iteration. Unlike break, continue does not stop the loop entirely; it only skips over the
remaining code in the current iteration and continues looping.

1 # Example of continue
2 for i in range(10):
3 if i % 2 == 0:
4 continue
5 print(i)

Output:

1
3
5
7
9

In this example, the continue statement is used to skip even numbers. When i is even, the program
jumps to the next iteration, and thus only odd numbers are printed.

Combining break and continue: You can use break and continue together in a loop to control the
flow in different ways. Here’s an example that demonstrates both statements in the same loop.

1 # Example of break and continue used together

2 for i in range(10):
3 if i == 7:
4 break # Stop the loop entirely when i is 7
5 if i % 2 == 0:
6 continue # Skip even numbers
7 print(i)

Output:

1
3
5

In this example, the loop skips over even numbers using continue, but when i equals 7, the break
statement is triggered, stopping the loop entirely. Therefore, only the odd numbers 1, 3, and 5 are
printed before the loop exits.
 62 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

5.10 Functions in Python

5.10.1 def Keyword and Function Basics

Functions in Python are blocks of reusable code that perform a specific task. They allow you to struc-
ture your code more efficiently and avoid repetition. Functions are defined using the def keyword
followed by the function name, parentheses (), and a colon :. Inside the function, you can write the
code that will execute when the function is called. Functions can also take parameters and return
values.
Here is the basic syntax for defining a function:
1 def function_name(parameters):
2 # code to be executed
3 return result

Basic Example:

A simple function that takes no arguments and returns a greeting message can be defined as follows:
1 def greet():
2 return "Hello, World!"

To call the function and see the result, you can write:
1 # Call the function
2 print(greet())

Output:
Hello, World!

In this example, the function greet() is defined with no parameters and returns the string "Hello,
World!". The function is called using its name followed by parentheses, and the result is printed.

Functions with Parameters

Functions can also take parameters, which allow you to pass data into the function. These parameters
are specified inside the parentheses when the function is defined.
1 # Function with a parameter
2 def greet(name):
3 return f"Hello, {name}!"

When calling the function, you pass an argument to the parameter:

1 # Call the function with an argument
2 print(greet("Alice"))

Output:
Hello, Alice!

In this case, the function greet() takes one parameter, name, and returns a personalized greeting.
When the function is called with "Alice" as the argument, it returns "Hello, Alice!".
 5.10. FUNCTIONS IN PYTHON 63

Functions with Multiple Parameters

Functions can accept multiple parameters by separating them with commas. Here is an example:

1 # Function with multiple parameters

2 def add_numbers(a, b):
3 return a + b

You can call the function by providing two arguments:

1 # Call the function with two arguments

2 print(add_numbers(3, 5))

Output:

In this example, the function add_numbers() takes two parameters, a and b, and returns their sum.
When called with the arguments 3 and 5, the function returns 8.

Returning Values from Functions

A function can return a value using the return statement. The returned value can be stored in a variable
or used directly. Here’s an example:

1 # Function that returns a value

2 def square(x):
3 return x * x

To use the returned value, you can assign it to a variable:

1 # Call the function and store the result

2 result = square(4)
3 print(result)

Output:

16

In this example, the function square() returns the square of the argument x. When called with the
argument 4, the function returns 16, which is then stored in the variable result and printed.

Default Parameters

Python allows you to define functions with default parameter values. If an argument is not provided
when calling the function, the default value is used.
If no argument is passed, the default value "Guest" is used:

1 # Function with a default parameter

2 def greet(name="Guest"):
3 return f"Hello, {name}!"
4

5 # Call the function without an argument

6 print(greet())
 64 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

8 # Call the function with an argument

9 print(greet("Alice"))

Output:
Hello, Guest!
Hello, Alice!

In this case, the function greet() has a default parameter value of "Guest". If no argument is
provided, the function returns "Hello, Guest!". If an argument is provided, it overrides the default
value.

5.10.2 Recursion in Python

To iterate is human, to recurse, divine!

Recursion is a technique in programming where a function calls itself to solve a problem. Recursive
functions break a problem down into smaller subproblems, and the function continues to call itself
with these smaller subproblems until it reaches a base case, which is a condition that stops the re-
cursion. Recursion is useful for tasks that can be naturally divided into similar, smaller tasks, such as
mathematical problems or traversing tree-like structures.
To write a recursive function in Python, you define the function using def, and within the function,
call the function itself with a modified argument. You also need to define a base case to prevent the
recursion from running indefinitely.

Basic Example of Recursion: Factorial Function

A classic example of recursion is calculating the factorial of a number. The factorial of a number n is
defined as n × (n − 1) × (n − 2) × · · · × 1, and can be expressed recursively as:

n! = n × (n − 1)!

The base case for the recursion is when n = 0, where 0! = 1.

Here is how you would implement this in Python:
1 # Recursive function to calculate factorial
2 def factorial(n):
3 if n == 0:
4 return 1
5 else:
6 return n * factorial(n - 1)

To calculate the factorial of 5:

1 # Call the recursive factorial function
2 print(factorial(5))

Output:
120
 5.10. FUNCTIONS IN PYTHON 65

In this example, the function factorial() calls itself with n − 1 until n = 0, at which point the base
case is reached, and the recursion stops.

Recursive Fibonacci Sequence

Another common example of recursion is calculating numbers in the Fibonacci sequence. In the Fi-
bonacci sequence, each number is the sum of the two preceding ones, starting from 0 and 1. Mathe-
matically, it can be expressed as:

F (0) = 0, F (1) = 1, F (n) = F (n − 1) + F (n − 2) for n > 1

Here’s the recursive implementation of the Fibonacci sequence in Python:
1 # Recursive function to calculate Fibonacci numbers
2 def fibonacci(n):
3 if n == 0:
4 return 0
5 elif n == 1:
6 return 1
7 else:
8 return fibonacci(n - 1) + fibonacci(n - 2)

To calculate the 6th Fibonacci number:

1 # Call the recursive Fibonacci function
2 print(fibonacci(6))

Output:
8

In this example, the function fibonacci() recursively calls itself to compute the Fibonacci number
for n − 1 and n − 2, continuing until the base cases n = 0 or n = 1 are reached.

Base Case and Recursive Case

Every recursive function needs two essential components:

• Base case: This is the condition that stops the recursion. Without a base case, the function
would call itself infinitely.

• Recursive case: This is the part of the function that reduces the problem into smaller instances
and continues the recursion.

In the factorial example, the base case is when n == 0, and in the Fibonacci example, the base
cases are when n == 0 and n == 1.

Caution with Recursion

Recursion can be an elegant solution to certain problems, but it comes with some trade-offs. Recursive
functions consume memory with each function call, and Python has a limit on the depth of recursion
to prevent stack overflow. If recursion goes too deep, you may encounter a RecursionError. To avoid
this, make sure your recursive algorithm reaches a base case for all possible inputs.
 66 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

You can check the recursion limit in Python using:

1 import sys
2 print(sys.getrecursionlimit())

By default, Python sets the recursion limit to 1000. If necessary, you can increase the recursion
limit, but it’s generally better to refactor the recursive algorithm if it becomes too deep.

5.11 Simple Sorting Algorithms

Sorting algorithms are used to rearrange elements in a list or array so that they are in a specific order,
such as ascending or descending. This section introduces two simple and commonly used sorting
algorithms: Bubble Sort and Insertion Sort. Both algorithms are easy to understand and implement,
making them a good starting point for learning about sorting in computer science [23].

5.11.1 Bubble Sort

Bubble Sort is a simple comparison-based sorting algorithm. It works by repeatedly stepping through
the list, comparing adjacent elements, and swapping them if they are in the wrong order. The process
is repeated until the list is sorted. The largest unsorted element "bubbles" to the top with each pass,
hence the name "Bubble Sort."
Here is the basic concept of Bubble Sort:

1. Compare adjacent elements.

2. If the first is greater than the second, swap them.

3. Continue this process for each pair of adjacent elements.

4. Repeat the process for the entire list until it is sorted, regardless of whether swaps were made
or not during a pass.

Here is the modified Python implementation of Bubble Sort where the algorithm always runs for
all iterations without early exit:
1 # Bubble Sort algorithm in Python (without early exit)
2 def bubble_sort(arr):
3 n = len(arr)
4 for i in range(n):
5 # Traverse the array and perform comparisons and swaps
6 for j in range(0, n-i-1):
7 # Compare adjacent elements
8 if arr[j] > arr[j+1]:
9 # Swap if they are in the wrong order
10 arr[j], arr[j+1] = arr[j+1], arr[j]

To use the function:

1 # Example usage of bubble_sort
2 arr = [64, 34, 25, 12, 22, 11, 90]
3 bubble_sort(arr)
4 print("Sorted array:", arr)
 5.11. SIMPLE SORTING ALGORITHMS 67

Output:

Sorted array: [11, 12, 22, 25, 34, 64, 90]

Bubble Sort is easy to understand but is not very efficient for large datasets due to its time com-
plexity of O(n2 ). It is best suited for small datasets or educational purposes.

5.11.2 Insertion Sort

Insertion Sort is another simple sorting algorithm that builds the final sorted array one item at a time.
It works by taking an element from the unsorted portion of the array and inserting it into the correct
position in the sorted portion of the array. Insertion Sort is particularly useful for small or nearly sorted
datasets.
The basic concept of Insertion Sort: - Start with the second element of the array. - Compare it with
the elements before it and insert it in the correct position. - Repeat this process for all elements in the
array.
Here is the Python implementation of Insertion Sort:

1 # Insertion Sort algorithm in Python

2 def insertion_sort(arr):
3 for i in range(1, len(arr)):
4 key = arr[i]
5 j = i - 1
6 # Move elements of arr[0...i-1], that are greater than key, to one position ahead
7 while j >= 0 and key < arr[j]:
8 arr[j + 1] = arr[j]
9 j -= 1
10 arr[j + 1] = key

To use the function:

1 # Example usage of insertion_sort

2 arr = [12, 11, 13, 5, 6]
3 insertion_sort(arr)
4 print("Sorted array:", arr)

Output:

Sorted array: [5, 6, 11, 12, 13]

Insertion Sort has a time complexity of O(n2 ), similar to Bubble Sort, but it is more efficient when
the dataset is already partially sorted. It performs well for small datasets and is often used in practice
for such cases.

5.11.3 Python’s Built-in sort()

Python provides a highly efficient built-in sorting method called sort() for lists. This method is im-
plemented using an algorithm called Timsort, which is a hybrid sorting algorithm derived from merge
sort and insertion sort. Timsort is designed to perform well on real-world data by taking advantage
of runs (already sorted subsections of data) and has an average-case time complexity of O(n log n),
making it much more efficient than the simple algorithms like Bubble Sort and Insertion Sort.
 68 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING

Here’s how you can use the built-in sort() method in Python:
1 # Using Python's built-in sort() method
2 arr = [64, 34, 25, 12, 22, 11, 90]
3 arr.sort()
4 print("Sorted array:", arr)

Output:
Sorted array: [11, 12, 22, 25, 34, 64, 90]

This built-in sort() method works efficiently with large datasets and offers various customization
options, such as specifying a key function or sorting in reverse order. Additionally, Python’s built-in sort
is stable, meaning it preserves the relative order of elements with equal values, which can be useful in
certain applications.
To sort a list in descending order, you can pass the reverse=True argument:
1 # Sorting in descending order
2 arr.sort(reverse=True)
3 print("Sorted array in descending order:", arr)

Output:
Sorted array in descending order: [90, 64, 34, 25, 22, 12, 11]

Overall, Python’s built-in sort() is highly optimized and should be preferred for most sorting tasks,
especially when dealing with large datasets. It offers a significant performance improvement com-
pared to simpler sorting algorithms like Bubble Sort and Insertion Sort, making it the go-to choice for
efficient sorting in Python.

5.11.4 Comparing the Time of Bubble Sort, Insertion Sort, and Python’s Built-in
sort()
To compare the efficiency of Bubble Sort, Insertion Sort, and Python’s built-in sort() method, we can
measure the time each algorithm takes to sort the same list. Below is a Python example that uses the
time module to measure the time for each sorting algorithm.
1 import time
2

3 # Bubble Sort algorithm

4 def bubble_sort(arr):
5 n = len(arr)
6 for i in range(n):
7 for j in range(0, n-i-1):
8 if arr[j] > arr[j+1]:
9 arr[j], arr[j+1] = arr[j+1], arr[j]
10

11 # Insertion Sort algorithm

12 def insertion_sort(arr):
13 for i in range(1, len(arr)):
14 key = arr[i]
15 j = i - 1
 5.11. SIMPLE SORTING ALGORITHMS 69

16 while j >= 0 and key < arr[j]:

17 arr[j + 1] = arr[j]
18 j -= 1
19 arr[j + 1] = key
20

21 # Test arrays and function to measure time

22 def measure_time(sort_func, arr):
23 start_time = time.perf_counter()
24 sort_func(arr)
25 end_time = time.perf_counter()
26 return (end_time - start_time) * 1000
27

28 # Generate a list of random numbers for sorting

29 import random
30 arr_size = 1000
31 arr = [random.randint(1, 1000) for _ in range(arr_size)]
32

33 # Measure time for Bubble Sort

34 arr_bubble = arr.copy()
35 bubble_sort_time = measure_time(bubble_sort, arr_bubble)
36

37 # Measure time for Insertion Sort

38 arr_insertion = arr.copy()
39 insertion_sort_time = measure_time(insertion_sort, arr_insertion)
40

41 # Print the results

42 arr_builtin = arr.copy()
43 builtin_sort_time = measure_time(sorted, arr_builtin)
44

45 # Print results (precise to milliseconds)

46 print(f"Bubble Sort took: {bubble_sort_time:.3f} milliseconds")
47 print(f"Insertion Sort took: {insertion_sort_time:.3f} milliseconds")
48 print(f"Built-in sort() took: {builtin_sort_time:.3f} milliseconds")

Output:

Bubble Sort took: 30.357 milliseconds

Insertion Sort took: 12.514 milliseconds
Built-in sort() took: 0.091 milliseconds

This code compares the time taken by Bubble Sort, Insertion Sort, and Python’s built-in sort()
function to sort a list of 1000 random integers. The results are printed in milliseconds, and as expected,
Python’s built-in sort() is significantly faster due to its highly optimized Timsort algorithm. While
Bubble Sort and Insertion Sort are easy to implement and understand, they are inefficient for large
datasets. The built-in sort() should be the preferred choice when performance is critical.
70 CHAPTER 5. INTRODUCTION TO PYTHON PROGRAMMING
Chapter 6

Python for Data Science

6.1 Commonly used Datasets

In the realm of data science and machine learning, datasets are the backbone of any analytical pro-
cess. They serve as the fundamental building blocks upon which models are trained, validated, and
tested. High-quality datasets enable researchers and practitioners to extract meaningful insights, iden-
tify patterns, and make data-driven decisions. The availability and selection of appropriate datasets
are crucial, as they directly influence the accuracy, reliability, and generalizability of the models de-
veloped. As a result, understanding and utilizing commonly used datasets is essential for advancing
research and developing innovative solutions across various domains.
In this chapter, we will introduce several fundamental datasets that are crucial in the fields of ma-
chine learning and deep learning. These datasets are widely used for model development and testing.
The datasets covered include:

• Iris: The Iris dataset is one of the most classic datasets in machine learning, commonly used
for teaching and research in classification algorithms. The dataset contains 150 records, each
with 4 features (sepal length, sepal width, petal length, and petal width) and a target label (Iris
setosa, Iris versicolor, Iris virginica) [29]. Although the dataset is small, it is significant due to its
simplicity and historical importance in education.

• MNIST: The MNIST (Modified National Institute of Standards and Technology) dataset consists
of 70,000 images of handwritten digits (0-9), with 60,000 used for training and 10,000 for test-
ing [57]. Each image has a resolution of 28x28 pixels in grayscale. The MNIST dataset is one of
the benchmark datasets for image classification tasks, widely used to evaluate the performance
of image processing and machine learning algorithms.

• Fashion-MNIST: Fashion-MNIST is a dataset of images of clothing and accessories, designed

to serve as a more challenging replacement for MNIST as a benchmark for image classifica-
tion [104]. The dataset also contains 70,000 images (60,000 training and 10,000 testing), each
with a resolution of 28x28 pixels in grayscale. The labels in Fashion-MNIST include 10 classes
such as T-shirts, trousers, and shoes.

• CIFAR-10/CIFAR-100: CIFAR-10 and CIFAR-100 are two widely used datasets for image classifi-
cation [53]. CIFAR-10 consists of 60,000 32x32 pixel color images, divided into 10 classes with
6,000 images per class. CIFAR-100 has a similar structure but includes 100 classes with 600

71
72 CHAPTER 6. PYTHON FOR DATA SCIENCE

images per class. These datasets are well-known for evaluating convolutional neural networks
(CNNs) and other image-processing algorithms.

• ImageNet: The ImageNet dataset is a large-scale visual database containing over 14 million
labeled images, categorized into 1,000 classes [26]. This dataset is a significant benchmark in
the field of computer vision, especially for tasks like image classification, object detection, and
image segmentation. The annual ImageNet challenge (ImageNet Large Scale Visual Recognition
Challenge, ILSVRC) has been a key driver in the development of deep learning and convolutional
neural networks.

These datasets have become indispensable resources in machine learning and deep learning re-
search due to their wide application and influence. In the following sections, we will explore these
datasets in more detail, discussing their characteristics and applications.

6.1.1 Iris Dataset

The Iris dataset is one of the most famous and widely used datasets in machine learning and statis-
tical analysis. It was first introduced by British statistician and biologist Ronald A. Fisher in 1936 as
an example of linear discriminant analysis. The dataset contains 150 samples of iris flowers, each
described by four features and a class label.
Structure of the dataset:

• Number of samples: 150

• Number of classes: 3 different iris species:

– Iris-setosa
– Iris-versicolor
– Iris-virginica

• Features:

– Sepal Length
– Sepal Width
– Petal Length
– Petal Width

Each sample in the dataset is described by these four morphological features, and the goal is to
classify the samples into the three species using machine learning algorithms.
Uses of the dataset:

• Classification problem: Since the iris species are clearly labeled, this dataset is frequently used
to test and compare different classification algorithms.

• Visualization: Due to its small size and intuitive features, the Iris dataset is often used for data
visualization, especially for beginners.

• Model validation: The dataset is commonly used to validate the performance of machine learn-
ing models, particularly in supervised learning classification tasks.
 6.1. COMMONLY USED DATASETS 73

The Iris dataset is widely used in machine learning education and research and is included as a
built-in dataset in many open-source machine learning libraries, such as scikit-learn.
The Iris dataset is relatively small, so the entire dataset is provided here for readers to study. To
facilitate its use in a Python environment, the code below demonstrates how to import the Iris dataset
using the “sklearn” library, print the dataset’s dimensions, and display them.

1 from sklearn.datasets import load_iris

2

3 # Load the Iris dataset

4 iris = load_iris()
5

6 # Print the shape of the dataset

7 print("Dataset shape:", iris.data.shape)
8

9 # Print the shape of the target labels

10 print("Target shape:", iris.target.shape)

Listing 6.1: Importing the Iris Dataset

After executing the code above, you will see the dimensions of the dataset and the target labels
displayed as follows:
 
Dataset shape: (150, 4)
Target shape: (150,)
 
Listing 6.2: Iris Dataset and Target Dimensions

Table 6.1: Iris Dataset - Sepal and Petal Measurements for Different
Varieties

Sepal Sepal Petal Petal Variety Sepal Sepal Petal Petal Variety
Length Width Length Width Length Width Length Width
5.1 3.5 1.4 0.2 Setosa 4.9 3.0 1.4 0.2 Setosa
4.7 3.2 1.3 0.2 Setosa 4.6 3.1 1.5 0.2 Setosa
5.0 3.6 1.4 0.2 Setosa 5.4 3.9 1.7 0.4 Setosa
4.6 3.4 1.4 0.3 Setosa 5.0 3.4 1.5 0.2 Setosa
4.4 2.9 1.4 0.2 Setosa 4.9 3.1 1.5 0.1 Setosa
5.4 3.7 1.5 0.2 Setosa 4.8 3.4 1.6 0.2 Setosa
4.8 3.0 1.4 0.1 Setosa 4.3 3.0 1.1 0.1 Setosa
5.8 4.0 1.2 0.2 Setosa 5.7 4.4 1.5 0.4 Setosa
5.4 3.9 1.3 0.4 Setosa 5.1 3.5 1.4 0.3 Setosa
5.7 3.8 1.7 0.3 Setosa 5.1 3.8 1.5 0.3 Setosa
5.4 3.4 1.7 0.2 Setosa 5.1 3.7 1.5 0.4 Setosa
4.6 3.6 1.0 0.2 Setosa 5.1 3.3 1.7 0.5 Setosa
4.8 3.4 1.9 0.2 Setosa 5.0 3.0 1.6 0.2 Setosa
5.0 3.4 1.6 0.4 Setosa 5.2 3.5 1.5 0.2 Setosa
5.2 3.4 1.4 0.2 Setosa 4.7 3.2 1.6 0.2 Setosa
4.8 3.1 1.6 0.2 Setosa 5.4 3.4 1.5 0.4 Setosa
74 CHAPTER 6. PYTHON FOR DATA SCIENCE

Table 6.1: (Continued)

Sepal Sepal Petal Petal Variety Sepal Sepal Petal Petal Variety
Length Width Length Width Length Width Length Width
5.2 4.1 1.5 0.1 Setosa 5.5 4.2 1.4 0.2 Setosa
4.9 3.1 1.5 0.2 Setosa 5.0 3.2 1.2 0.2 Setosa
5.5 3.5 1.3 0.2 Setosa 4.9 3.6 1.4 0.1 Setosa
4.4 3.0 1.3 0.2 Setosa 5.1 3.4 1.5 0.2 Setosa
5.0 3.5 1.3 0.3 Setosa 4.5 2.3 1.3 0.3 Setosa
4.4 3.2 1.3 0.2 Setosa 5.0 3.5 1.6 0.6 Setosa
5.1 3.8 1.9 0.4 Setosa 4.8 3.0 1.4 0.3 Setosa
5.1 3.8 1.6 0.2 Setosa 4.6 3.2 1.4 0.2 Setosa
5.3 3.7 1.5 0.2 Setosa 5.0 3.3 1.4 0.2 Setosa
7.0 3.2 4.7 1.4 Versicolor 6.4 3.2 4.5 1.5 Versicolor
6.9 3.1 4.9 1.5 Versicolor 5.5 2.3 4.0 1.3 Versicolor
6.5 2.8 4.6 1.5 Versicolor 5.7 2.8 4.5 1.3 Versicolor
6.3 3.3 4.7 1.6 Versicolor 4.9 2.4 3.3 1.0 Versicolor
6.6 2.9 4.6 1.3 Versicolor 5.2 2.7 3.9 1.4 Versicolor
5.0 2.0 3.5 1.0 Versicolor 5.9 3.0 4.2 1.5 Versicolor
6.0 2.2 4.0 1.0 Versicolor 6.1 2.9 4.7 1.4 Versicolor
5.6 2.9 3.6 1.3 Versicolor 6.7 3.1 4.4 1.4 Versicolor
5.6 3.0 4.5 1.5 Versicolor 5.8 2.7 4.1 1.0 Versicolor
6.2 2.2 4.5 1.5 Versicolor 5.6 2.5 3.9 1.1 Versicolor
5.9 3.2 4.8 1.8 Versicolor 6.1 2.8 4.0 1.3 Versicolor
6.3 2.5 4.9 1.5 Versicolor 6.1 2.8 4.7 1.2 Versicolor
6.4 2.9 4.3 1.3 Versicolor 6.6 3.0 4.4 1.4 Versicolor
6.8 2.8 4.8 1.4 Versicolor 6.7 3.0 5.0 1.7 Versicolor
6.0 2.9 4.5 1.5 Versicolor 5.7 2.6 3.5 1.0 Versicolor
5.5 2.4 3.8 1.1 Versicolor 5.5 2.4 3.7 1.0 Versicolor
5.8 2.7 3.9 1.2 Versicolor 6.0 2.7 5.1 1.6 Versicolor
5.4 3.0 4.5 1.5 Versicolor 6.0 3.4 4.5 1.6 Versicolor
6.7 3.1 4.7 1.5 Versicolor 6.3 2.3 4.4 1.3 Versicolor
5.6 3.0 4.1 1.3 Versicolor 5.5 2.5 4.0 1.3 Versicolor
5.5 2.6 4.4 1.2 Versicolor 6.1 3.0 4.6 1.4 Versicolor
5.8 2.6 4.0 1.2 Versicolor 5.0 2.3 3.3 1.0 Versicolor
5.6 2.7 4.2 1.3 Versicolor 5.7 3.0 4.2 1.2 Versicolor
5.7 2.9 4.2 1.3 Versicolor 6.2 2.9 4.3 1.3 Versicolor
5.1 2.5 3.0 1.1 Versicolor 5.7 2.8 4.1 1.3 Versicolor
6.3 3.3 6.0 2.5 Virginica 5.8 2.7 5.1 1.9 Virginica
7.1 3.0 5.9 2.1 Virginica 6.3 2.9 5.6 1.8 Virginica
6.5 3.0 5.8 2.2 Virginica 7.6 3.0 6.6 2.1 Virginica
4.9 2.5 4.5 1.7 Virginica 7.3 2.9 6.3 1.8 Virginica
6.7 2.5 5.8 1.8 Virginica 7.2 3.6 6.1 2.5 Virginica
6.5 3.2 5.1 2.0 Virginica 6.4 2.7 5.3 1.9 Virginica
6.1. COMMONLY USED DATASETS 75

Table 6.1: (Continued)

Sepal Sepal Petal Petal Variety Sepal Sepal Petal Petal Variety
Length Width Length Width Length Width Length Width
6.8 3.0 5.5 2.1 Virginica 5.7 2.5 5.0 2.0 Virginica
5.8 2.8 5.1 2.4 Virginica 6.4 3.2 5.3 2.3 Virginica
6.5 3.0 5.5 1.8 Virginica 7.7 3.8 6.7 2.2 Virginica
7.7 2.6 6.9 2.3 Virginica 6.0 2.2 5.0 1.5 Virginica
6.9 3.2 5.7 2.3 Virginica 5.6 2.8 4.9 2.0 Virginica
7.7 2.8 6.7 2.0 Virginica 6.3 2.7 4.9 1.8 Virginica
6.7 3.3 5.7 2.1 Virginica 7.2 3.2 6.0 1.8 Virginica
6.2 2.8 4.8 1.8 Virginica 6.1 3.0 4.9 1.8 Virginica
6.4 2.8 5.6 2.1 Virginica 7.2 3.0 5.8 1.6 Virginica
7.4 2.8 6.1 1.9 Virginica 7.9 3.8 6.4 2.0 Virginica
6.4 2.8 5.6 2.2 Virginica 6.3 2.8 5.1 1.5 Virginica
6.1 2.6 5.6 1.4 Virginica 7.7 3.0 6.1 2.3 Virginica
6.3 3.4 5.6 2.4 Virginica 6.4 3.1 5.5 1.8 Virginica
6.0 3.0 4.8 1.8 Virginica 6.9 3.1 5.4 2.1 Virginica
6.7 3.1 5.6 2.4 Virginica 6.9 3.1 5.1 2.3 Virginica
5.8 2.7 5.1 1.9 Virginica 6.8 3.2 5.9 2.3 Virginica
6.7 3.3 5.7 2.5 Virginica 6.7 3.0 5.2 2.3 Virginica
6.3 2.5 5.0 1.9 Virginica 6.5 3.0 5.2 2.0 Virginica
6.2 3.4 5.4 2.3 Virginica 5.9 3.0 5.1 1.8 Virginica
76 CHAPTER 6. PYTHON FOR DATA SCIENCE
Chapter 7

Introduction to Machine Learning

This chapter will cover the fundamentals of machine learning, providing a comprehensive overview of
various types, methodologies, and practical applications.

7.1 What is Machine Learning?

7.1.1 Definition and Overview

Machine learning (ML) is a branch of artificial intelligence that focuses on developing algorithms and
statistical models that enable computers to perform tasks without explicit instructions, relying instead
on patterns and inferences derived from data. Unlike traditional programming paradigms where hu-
mans explicitly program the logic and rules, machine learning algorithms build a model based on input
data and use it to make predictions or decisions without being explicitly programmed to perform the
task.
Core Concept: The core idea behind machine learning is to create models that can generalize from
their training data to new, unseen data. This generalization ability makes machine learning a powerful
tool in many fields, including natural language processing, computer vision, healthcare, finance, and
beyond.
How It Works: Machine learning typically involves three primary components:

• Model: The system that makes predictions or identifications.

• Parameters: The factors considered by the model (often adjusted during training).

• Learner: The algorithm that adjusts the parameters and improves the model based on its perfor-
mance on training data.

Machine learning models are often described as either supervised or unsupervised, which refers
to whether the model is trained with human supervision (i.e., the data is labeled) or without it.
Supervised Learning: This approach involves training a model on a labeled dataset, which means
that each example in the training set is tagged with the correct answer (the label) [13]. The learning
algorithm gets a sample of data and then makes adjustments to the model to minimize errors. After
numerous iterations, the model aims for the smallest possible number of errors when predicting labels
on new, unseen data.
Unsupervised Learning: In contrast, unsupervised learning involves training a model on data that
does not have labeled responses [37]. Here, the goal is to infer the natural structure present within

77
78 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING

a set of data points. It includes clustering [43] and association algorithms [3] that group objects of
similar kinds into respective categories and discover interesting patterns in data.
Comparing to Traditional Programming: Traditional computational approaches typically require a
clear set of instructions and do not change unless explicitly updated by a human. In contrast, machine
learning algorithms are designed to learn from data and update themselves in response to that data.
This capability allows them to adapt to new trends or unknown variables without human intervention.
Why is Machine Learning Important?

1. Adaptability: ML can adapt to new trends as it learns from the data. This makes it particularly
useful for applications where it is impractical or impossible to program explicit, rule-based in-
structions.

2. Scale: ML algorithms can handle vast amounts of data and complex variable interactions that
are too complex for human analysts to handle.

3. Automation and Decision-making: ML can automate routine processes and make decisions in
real time based on data analysis, which can significantly enhance the efficiency and effective-
ness of systems across different industries.

Challenges in Machine Learning: While machine learning offers significant advantages, it also
comes with its own set of challenges, such as ensuring the quality of data, dealing with imbalanced
and unstructured data, interpreting model results, and maintaining privacy and security.
In conclusion, machine learning represents a significant shift in how computers can learn and make
decisions. It bridges the gap between human programming capabilities and computational speed,
making it a key driver of innovation and efficiency in the modern digital era.

7.1.2 History and Evolution of Machine Learning

The journey of machine learning (ML) is rich and storied, intersecting with the histories of statistics,
mathematics, engineering, and computer science. Understanding its evolution not only illuminates
how we’ve reached current technological capabilities but also sheds light on where the field might
head next.
Early Beginnings: The roots of machine learning are deeply entwined with the development of
computers and early notions of artificial intelligence (AI). In the 1950s, Alan Turing, often hailed as
the father of theoretical computer science and artificial intelligence, proposed the question, "Can ma-
chines think?" which sparked interest and speculation in the possibility of intelligent machines. This
led to the design of the Turing Test, a method for determining whether a machine could exhibit intelli-
gent behavior indistinguishable from that of a human.
The Birth of Neural Networks: In 1957, Frank Rosenblatt invented the Perceptron, an early type of
neural network, at the Cornell Aeronautical Laboratory. The Perceptron was designed to simulate the
thought processes of the human brain, albeit in a very primitive form. Although limited in functionality
and initially criticized, this laid the groundwork for future research in neural networks.
Symbolic AI and Expert Systems: The 1960s and 1970s witnessed the rise of symbolic AI, charac-
terized by the development of expert systems that attempted to encapsulate the knowledge of human
experts into a computer system. These systems were rule-based, using if-then rules to solve problems
in narrow domains, such as medical diagnosis or mineral prospecting.
AI Winter and its Impact: Despite initial enthusiasm, the limitations of neural networks and sym-
bolic AI soon became apparent, leading to the first "AI Winter" in the late 1970s and early 1980s, a
7.1. WHAT IS MACHINE LEARNING? 79

period marked by reduced funding and waning interest in AI research. A second AI winter occurred in
the late 1980s, following overly optimistic predictions that failed to materialize.
The Revival and Growth of Neural Networks: The 1980s saw a revival of interest in neural networks
thanks to the backpropagation algorithm, which allowed networks to adjust their hidden layers of
neurons in situations where the output did not match the target value, effectively enabling deeper
learning. The invention of Convolutional Neural Networks (CNNs) by Yann LeCun [56] in 1989 further
advanced the field, particularly in image and video processing applications.
The Rise of Big Data and Advanced Algorithms: The 21st century has seen an explosion in data
generation and the computational power necessary to process it. This era has been marked by signif-
icant advancements in algorithms and an increase in the use and sophistication of machine learning.
Notable developments include the introduction of Support Vector Machines, ensemble methods like
Random Forests, and boosting techniques which have substantially increased the accuracy and ap-
plicability of predictive models.
Deep Learning Breakthroughs: In 2012, a landmark event in the history of machine learning oc-
curred when a deep learning model designed by Geoffrey Hinton and his team won the ImageNet [26]
competition by a large margin. This victory underscored the potential of deep learning, leading to its
widespread adoption across various sectors, including speech recognition, autonomous vehicles, and
medical diagnostics.
Current Trends and Future Directions: Today, machine learning is ubiquitous, powering search
engines, recommender systems, speech recognition, and numerous other applications. The focus has
shifted towards making AI more accessible and ethical, improving model interpretability, and moving
towards unsupervised learning techniques that require less human supervision.
The field of machine learning continues to evolve, driven by a community of researchers and prac-
titioners dedicated to pushing the boundaries of what machines can learn. As we look to the future,
the ongoing integration of AI with other technologies promises to transform industries and societies
in profound ways.
In conclusion, the history of machine learning is a testament to the collaborative, interdisciplinary
efforts that have driven advances in this field, highlighting an exciting trajectory from theoretical ex-
ploration to practical, transformative technologies.

7.1.3 Machine Learning vs. Traditional Programming

Understanding the differences between machine learning (ML) and traditional programming is essen-
tial to appreciate the unique advantages that ML brings to various computational tasks. Traditional
programming and machine learning fundamentally differ in their approach to problem-solving, adapt-
ability, and application complexity.
Fundamental Approach:

• Traditional Programming: In traditional programming, a programmer writes a set of explicit in-

structions (code) to process input data and produce the desired output. The logic and rules are
explicitly defined, and the program execution paths are predetermined. This method is effective
for problems with well-understood parameters and clearly defined rules where the outcomes are
predictable.

• Machine Learning: Conversely, machine learning algorithms infer rules from provided data. In-
stead of being explicitly programmed for each step, an ML model is trained using a large amount
80 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING

of data, learning the patterns or statistical representations required to perform a task. This ap-
proach is particularly advantageous for complex problems where defining explicit rules is im-
practical or impossible.

Adaptability and Flexibility:

• Traditional Programming: Once a traditional software solution is developed, it performs the

same operations unless it is manually updated or modified by developers. This static nature
limits its adaptability to new data or changing environments without human intervention.

• Machine Learning: ML models excel in environments where they continuously learn and adapt
from new data, improving their accuracy and efficiency over time without human intervention.
This makes them highly suitable for dynamic and evolving tasks such as personalized recom-
mendations, real-time fraud detection, and predictive maintenance.

Handling of Complex Patterns and Large Data Volumes:

• Traditional Programming: Traditional methods struggle with large datasets or complex patterns
because they require the programmer to foresee and code for every possible scenario. The
complexity and volume of data can quickly become unmanageable, leading to rigid and brittle
systems.

• Machine Learning: Machine learning algorithms are designed to handle and analyze vast amounts
of data and detect complex patterns that may not be immediately apparent or predictable to hu-
man programmers. This capability is underpinned by ML’s ability to perform feature extraction
and dimensionality reduction, simplifying inputs without losing essential information.

Error Reduction and Precision:

• Traditional Programming: The precision and accuracy of traditional programs are limited by the
initial logic and algorithms coded by the programmer. Any errors in the code or oversight in the
logic can propagate and magnify throughout the application, leading to incorrect results.

• Machine Learning: ML models minimize errors through iterative learning. As more data be-
comes available and the model is trained over numerous cycles, it fine-tunes its algorithms to
improve accuracy and reduce errors, often surpassing human-level performance in tasks like
image recognition and language translation.

Scalability and Evolution:

• Traditional Programming: Scaling traditional software to accommodate more extensive data

sets or more complex decision-making scenarios often requires significant redesign and restruc-
turing, which can be time-consuming and costly.

• Machine Learning: ML models are inherently scalable, designed to improve as data volume
grows. This scalability makes them ideal for applications like social media trend analysis and
large-scale financial systems where data grows exponentially.

Conclusion: Machine learning represents a paradigm shift in how we approach problem-solving in

the realm of computing. Unlike traditional programming, which relies on human-made rules and logic,
machine learning offers a dynamic framework that learns from data, becoming more effective over
time and adaptable to new and changing environments. This shift not only enhances computational
tasks but also opens new possibilities for innovation across industries, reshaping how we interact with
technology in our daily lives.
7.2. TYPES OF MACHINE LEARNING 81

7.2 Types of Machine Learning

Machine learning is an important branch of artificial intelligence that enables computer systems to
automatically improve their performance through experience. Machine learning algorithms can be
categorized into several main types based on their learning methods and objectives. This section will
introduce in detail four main types of machine learning: supervised learning, unsupervised learning,
semi-supervised learning, and reinforcement learning.

7.2.1 Supervised Learning

Supervised learning is the most common and widely applied type of machine learning. In supervised
learning, algorithms learn the mapping from input to output through labeled training data.

Concept

The core idea of supervised learning is to learn a function through known input-output pairs (called
training sets) that can map new unseen inputs to correct outputs. The "supervision" here refers to the
correct output labels included in the training data, which the algorithm can constantly refer to during
the learning process to adjust its predictions.

Working Principle

1. Data Preparation: Collect labeled training data, usually including input features and correspond-
ing output labels.

2. Model Selection: Choose an appropriate algorithm model based on the nature of the problem,
such as linear regression, decision trees, neural networks, etc.

3. Model Training: Use training data to optimize model parameters, minimizing the error between
the model’s predicted output and actual labels.

4. Model Evaluation: Use test data not involved in training to evaluate the model’s generalization
ability.

5. Prediction: Use the trained model to make predictions on new unlabeled data.

Common Algorithms

• Linear Regression: A simple and effective algorithm for predicting continuous value outputs.

• Logistic Regression: Despite having "regression" in its name, it’s an algorithm for binary classifi-
cation problems.

• Decision Trees: A tree-based algorithm for classification and regression, easy to understand and
interpret.

• Random Forests: An algorithm that ensembles multiple decision trees, usually performing better
than a single decision tree.

• Support Vector Machines (SVM): A powerful classification algorithm, particularly suitable for
handling high-dimensional data.
82 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING

• Neural Networks: A class of algorithms inspired by biological neural systems, capable of learning
complex non-linear relationships.

Application Scenarios

• Image Classification: Recognizing objects in images, such as face recognition, handwritten digit
recognition, etc.

• Natural Language Processing: Text classification, sentiment analysis, machine translation, etc.

• Medical Diagnosis: Predicting disease risks or diagnosing diseases based on patient data.

• Financial Forecasting: Stock price prediction, credit risk assessment, etc.

• Recommendation Systems: Recommending products or content based on user historical be-

havior.

Advantages and Disadvantages

Advantages

• Performance is usually superior to other types of learning methods.

• Can produce explicit outputs.

• Applicable to various complex real-world problems.

Disadvantages

• Requires a large amount of labeled training data, which can be costly to obtain.

• May encounter overfitting problems, especially when training data is limited.

• Difficult to handle data of unknown categories.

Detailed Explanation

Supervised learning is one of the most commonly used methods in machine learning. Its core idea is
to learn a mapping function from input to output through labeled data. This process can be analogous
to having a "teacher" (i.e., the labeled data) guiding the learning process.
In supervised learning, we have a training dataset D = (x1, y1), (x2, y2), ..., (xn, yn), where xi is
the input feature and yi is the corresponding label or target value. The learning objective is to find a
function f such that for a new input x, f(x) can accurately predict the corresponding y.
Supervised learning can be further divided into two main types of problems:
1. Classification Problems: When the output variable y is a discrete category, such as determining
whether an email is spam or not.
2. Regression Problems: When the output variable y is a continuous value, such as predicting
house prices.
7.2. TYPES OF MACHINE LEARNING 83

Concrete Example

Let’s use a house price prediction problem as an example to illustrate the supervised learning process
in detail:
1. Data Collection: Collect historical house sale data, including the following features: - Area
(square meters) - Number of bedrooms - Number of bathrooms - Age of the house (years) - Location
- Sale price (target variable)
2. Data Preprocessing: - Handle missing values: For example, interpolate missing area data. -
Feature encoding: Convert categorical features like "location" into numerical form, such as one-hot
encoding. - Feature scaling: Normalize all features to the same scale, such as using Min-Max scaling.
3. Model Selection: For a regression problem like house price prediction, we can choose a linear
regression model: y = w0 + w1x1 + w2x2 + ... + wnxn where y is the predicted house price, xi are the
various features, and wi are the corresponding weights.
4. Model Training: Use optimization algorithms like gradient descent to find the optimal set of
weights that minimize prediction error. For example, we can use Mean Squared Error (MSE) as the
loss function:
n
1X
MSE = (yi − ŷi )2
n i=1

where yi is the actual house price and ŷi is the model’s predicted price.
5. Model Evaluation: Use techniques like cross-validation to evaluate the model’s performance.
For example, we can use the R² score to measure the model’s fit:
Pn
(yi − ŷi )2
R2 = 1 − Pi=1
n 2
i=1 (yi − ȳ)

where ȳ is the mean of the actual house prices.

6. Model Application: For a new house, we can input its features (area, number of bedrooms, etc.),
and the model will output a predicted price.
7. Model Update: As time goes on, we can collect new sales data to update the model, maintaining
its accuracy.
This example demonstrates the application process of supervised learning in a real-world problem.
Through this method, we can create a system that can predict prices based on house features, which
has important applications in real estate valuation, home buying decisions, and more.

7.2.2 Unsupervised Learning

Concept

Unsupervised learning is a branch of machine learning that deals with unlabeled data. This learning
method attempts to discover hidden structures or patterns from the data itself, without relying on
predefined outputs.
The main tasks of unsupervised learning include:
1. Clustering: Grouping similar data points. 2. Dimensionality Reduction: Reducing the number of
features in the data while preserving the main information. 3. Association Rule Learning: Discovering
relationships between data items. 4. Anomaly Detection: Identifying abnormal or rare data points.
The challenge in unsupervised learning is that, due to the lack of explicit target outputs, it’s difficult
to objectively evaluate the algorithm’s performance. Often, the interpretation and validation of results
require the involvement of domain experts.
84 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING

Working Principle

Steps in Unsupervised Learning

1. Data Collection: Collect unlabeled dataset.

2. Algorithm Selection: Choose a suitable unsupervised learning algorithm based on task objec-
tives.

3. Apply Algorithm: Apply the selected algorithm to the dataset.

4. Interpret Results: Analyze algorithm output to discover patterns or structures in the data.

5. Validation: Use domain knowledge or other methods to verify if the discovered patterns are
meaningful.

Common Algorithms

Unsupervised Learning Techniques

• K-means Clustering: Groups data points into a predetermined number of clusters [59].

• Hierarchical Clustering: Creates a tree-like hierarchy of data points [70].

• Principal Component Analysis (PCA): Used for dimensionality reduction and feature extraction [35].

• Independent Component Analysis (ICA): Decomposes multivariate signals into independent sub-
components [42].

• Self-Organizing Maps (SOM): A neural network method for data visualization [51].

• Gaussian Mixture Models: A probabilistic model assuming data is composed of multiple Gaus-
sian distributions [13].

• Association Rule Learning: Discovers relationships between items in large databases [3].

Application Scenarios

Applications of Data Analysis Techniques

• Market Segmentation: Dividing customers into different groups based on their behavior [101].

• Anomaly Detection: Identifying anomalies or outliers in datasets, such as fraud detection [19].

• Feature Learning: Automatically learning useful feature representations from raw data [12].

• Recommendation Systems: Recommending products or content based on user behavior pat-

terns [85].

• Gene Expression Analysis: Identifying patterns in gene expression data [80].

• Social Network Analysis: Discovering community structures in social networks [30].

7.2. TYPES OF MACHINE LEARNING 85

Advantages and Disadvantages

Advantages and Disadvantages

Advantages

• Does not require labeled data and can handle large amounts of unlabeled data.

• Can discover hidden patterns and structures in data.

• Can be used for data preprocessing and feature learning.

Disadvantages

• Results may be difficult to interpret or validate.

• Computational complexity is usually higher.

• Patterns discovered may not necessarily be useful for specific tasks.

Concrete Example

Let’s use customer segmentation as an example to illustrate the application process of unsupervised
learning in detail:
Suppose an e-commerce company wants to divide its customers into different groups based on
their purchasing behavior to develop targeted marketing strategies.
1. Data Collection: Collect the following information about customers: - Annual purchase amount
- Purchase frequency - Time since last purchase - Product categories browsed - Customer age - Cus-
tomer registration duration
2. Data Preprocessing: - Handle missing values: For example, interpolate missing age data. - Fea-
ture scaling: Normalize all features, such as using Z-score standardization. - Handle outliers: Remove
or adjust extreme values.
3. Algorithm Selection: For customer segmentation, we can use the K-means clustering algorithm.
4. Apply Algorithm: Steps of the K-means algorithm: a) Choose K initial center points (assume
K=3) b) Assign each data point to the nearest center point c) Recalculate the center point of each
cluster d) Repeat steps b and c until the center points no longer change significantly
5. Result Analysis: Suppose we get three customer groups: - Group A: High spending, high-frequency
purchases - Group B: Medium spending, occasional purchases - Group C: Low spending, rare pur-
chases
6. Result Application: Based on these groups, the company can develop different marketing strate-
gies: - Offer VIP services and exclusive discounts to Group A - Provide promotional activities to Group B
to encourage more frequent purchases - Offer entry-level products and discounts to Group C to attract
them to increase purchases
7. Continuous Optimization: - Regularly rerun the clustering algorithm, as customer behavior may
change over time - Try different K values to find the optimal number of groups - Combine with other
algorithms, such as Principal Component Analysis (PCA) for feature dimensionality reduction
This example demonstrates how unsupervised learning can help businesses understand customer
structure and develop more effective business strategies. By discovering hidden patterns in the data,
unsupervised learning provides valuable insights for decision-making.
Certainly! I’ll reformat the semi-supervised learning and reinforcement learning sections to match
the structure of supervised and unsupervised learning sections.
86 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING

7.2.3 Semi-supervised Learning

Semi-supervised learning is a machine learning approach that combines elements of both supervised
and unsupervised learning. It utilizes a small amount of labeled data along with a large amount of
unlabeled data to train models.

Concept

The core idea of semi-supervised learning [75] is to leverage the abundant unlabeled data to improve
the performance of models trained on limited labeled data. This approach is particularly useful in
scenarios where obtaining labeled data is expensive or time-consuming, but unlabeled data is plentiful.

Working Principle

Semi-Supervised Learning Process

1. Data Preparation: Collect a small set of labeled data and a large set of unlabeled data.

2. Initial Training: Train an initial model using the labeled data.

3. Pseudo-labeling: Use the initial model to generate pseudo-labels for part of the unlabeled data.

4. Model Update: Retrain the model using both the original labeled data and the pseudo-labeled
data.

5. Iteration: Repeat the pseudo-labeling and model update steps until convergence or a set number
of iterations.

Common Algorithms

Semi-Supervised Learning Methods

• Self-training: The model uses its predictions to generate labels for unlabeled data [105].

• Co-training: Multiple models learn from each other, each focusing on different aspects of the
data [14].

• Generative Models: Use generative models to model the data distribution [50].

• Graph-based Methods: Construct graphs based on relationships between data points, then prop-
agate labels on the graph [109].

• Semi-supervised SVMs: A variant of SVMs that incorporates unlabeled data [44].

Application Scenarios

1. Text Classification: Improving classification performance using large amounts of unlabeled text
data [72].
2. Image Recognition: Training models with few labeled images and many unlabeled images [81].
3. Speech Recognition: Enhancing recognition accuracy using large amounts of untranscribed
speech data [106].
7.2. TYPES OF MACHINE LEARNING 87

4. Bioinformatics: Predicting gene functions using few genes with known functions and many with
unknown functions [103].
5. Web Page Classification: Automatically classifying web pages using a few manually classified
pages and many unclassified ones [14].

Advantages and Disadvantages

Advantages

• Can significantly reduce the need for labeled data.

• Often performs better than supervised learning using only labeled data.

• Can leverage large amounts of easily obtainable unlabeled data.

Disadvantages

• Algorithm design and implementation can be complex.

• May introduce incorrect labels, leading to performance degradation.

• Theoretical foundations are relatively weak, and effectiveness depends on specific problems
and data distributions.

Concrete Example

Let’s use a text classification problem to illustrate the application of semi-supervised learning:
Suppose we’re building a news article classification system to categorize articles into four classes:
"Politics", "Sports", "Technology", and "Entertainment". We have a small number of manually labeled
articles and a large number of unlabeled articles.
1. Data Preparation: - Labeled data: 1,000 annotated news articles - Unlabeled data: 100,000 unan-
notated news articles
2. Feature Extraction: - Use TF-IDF (Term Frequency-Inverse Document Frequency) to convert text
into numerical features - Features include: word frequency, article length, and presence of specific
keywords
3. Initial Model Training: Train an initial Support Vector Machine (SVM) classifier using the 1,000
labeled articles
4. Self-training Process: a) Use the initial SVM to predict labels for the 100,000 unlabeled articles
b) Select the 10,000 articles with the highest prediction confidence c) Add these high-confidence pre-
dictions to the training set d) Retrain the SVM using the augmented training set (now 11,000 articles)
e) Repeat steps a-d for 5 iterations or until performance stabilizes
5. Model Evaluation: - Use 5-fold cross-validation to evaluate model performance - Compare the
performance of the SVM trained only on labeled data vs. the semi-supervised model
6. Results Analysis: Suppose we observe: - Initial SVM (1,000 labeled articles): 75- Semi-supervised
SVM (after 5 iterations): 85- "Politics" and "Sports" categories show the highest improvement - "Tech-
nology" and "Entertainment" still have some confusion
7. Practical Application: - Deploy the final model to classify incoming news articles - Implement
a feedback loop where human editors occasionally verify and correct classifications, providing newly
labeled data
88 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING

8. Continuous Improvement: - Periodically retrain the model with newly acquired labeled data -
Experiment with other semi-supervised methods like graph-based label propagation - Enhance feature
extraction by incorporating word embeddings
This example demonstrates how semi-supervised learning can significantly improve classification
performance by leveraging a large amount of unlabeled data, which is often readily available in real-
world scenarios.

7.2.4 Reinforcement Learning

Reinforcement learning [66] is a type of machine learning where an agent learns to make decisions by
interacting with an environment. It mimics the way humans and animals learn through trial and error.

Concept

In reinforcement learning, an intelligent agent learns by taking actions in an environment and observing
the results. Each action receives feedback from the environment, usually in the form of rewards or
penalties. The agent’s goal is to learn a policy that maximizes long-term cumulative rewards.

Working Principle

Agent Interaction Process

1. State Perception: The agent observes the current state of the environment.

2. Action Selection: Based on the current policy, the agent chooses an action.

3. Action Execution: The chosen action is executed in the environment.

4. Feedback Reception: The agent receives a reward or penalty from the environment.

5. State Transition: The environment transitions to a new state.

6. Policy Update: The action policy is updated based on the experience gained.

7. Repetition: The above steps are repeated, continuously improving the policy.

Key Concepts

Key Concepts in Reinforcement Learning

• Markov Decision Process (MDP): A mathematical framework for describing reinforcement learn-
ing problems [11].

• Value Function: Estimates the expected future rewards from a given state [96].

• Policy: A rule that determines what action to take in a given state [95].

• Exploration vs. Exploitation: Balancing between trying new actions (exploration) and choosing
known good actions (exploitation) [46].

• Temporal Difference Learning: Updating value estimates based on current estimates and ob-
served rewards.
7.2. TYPES OF MACHINE LEARNING 89

Common Algorithms

Reinforcement Learning Algorithms

• Q-learning: A model-free temporal difference learning algorithm [100].

• SARSA: Similar to Q-learning but considers the actual next action taken [87].

• Policy Gradient Methods: Directly optimize the policy without using a value function [97].

• Actor-Critic Methods: Combine policy gradient methods with value function estimation [52].

• Deep Q-Network (DQN): Combines Q-learning with deep learning [67].

• Proximal Policy Optimization (PPO): A popular policy optimization algorithm [89].

Application Scenarios

• Game AI: Such as AlphaGo in the game of Go [91].

• Robot Control: Learning complex motion and manipulation tasks [58].

• Autonomous Driving: Learning to make decisions in various traffic situations [47].

• Resource Management: Such as energy optimization in data centers [61].

• Recommendation Systems: Learning strategies to maximize long-term user satisfaction [108].

• Financial Trading: Developing automated trading strategies [69].

Advantages and Disadvantages

Advantages

• Can learn complex sequential decision-making problems.

• Does not require large amounts of labeled data.

• Can continuously learn and adapt to new environments.

Disadvantages

• The Training process can be unstable and requires a lot of trial and error.

• Slow convergence on some problems.

• Difficult to apply to problems with sparse or delayed reward signals.

This reformatted structure for semi-supervised learning and reinforcement learning sections now
matches the layout of the supervised and unsupervised learning sections, providing a consistent for-
mat throughout the chapter.

Concrete Example: Let’s illustrate reinforcement learning with an example of training an AI to play a
simple maze game:
90 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING

Game Setup:

• The maze is a 10x10 grid

• Starting point: upper left corner (0,0)

• Goal: lower right corner (9,9)

• Walls block certain paths

• The agent can move Up, Down, Left, or Right

Environment Definition:

• State: Agent’s position (x, y coordinates)

• Actions: Up, Down, Left, Right

• Rewards:

– Reaching the goal: +100

– Hitting a wall: -10
– Each step: -1 (to encourage finding the shortest path)

Q-table Initialization: Create a 100x4 table (100 states, 4 actions), initialize all values to 0.

Learning Parameters:

• Learning rate (α): 0.1

• Discount factor (γ): 0.9

• ϵ for ϵ-greedy strategy: initial value 0.9, decaying by 0.005 each episode

Training Process (Q-learning algorithm):

• For 1000 episodes:

(a) Start at (0,0)

(b) While not at (9,9):

* Choose action: ϵ probability of random action, else best Q-value action

* Execute action, observe new state, and reward
* Update Q-value:

Q(s, a) = Q(s, a) + α [r + γ · max(Q(s′ , a′ )) − Q(s, a)]

(c) Decrease ϵ by 0.005 (min 0.1)

Evaluation:

• After training, run 100 test episodes without exploration

• Record success rate and average steps to goal

7.3. KEY CONCEPTS AND TERMINOLOGIES 91

Results Analysis:

• Suppose we observe:

– First 100 episodes: 20% success rate, average 80 steps when successful
– Last 100 episodes: 95% success rate, average 20 steps
– Final test run: 98% success rate, average 18 steps

Visualization:

• Create a heatmap of the maze showing the most frequent path

• Plot learning curve (episode vs. steps to goal)

Further Improvements:

• Implement experience replay to improve sample efficiency

• Use a Deep Q-Network to handle larger, more complex mazes

• Add dynamic obstacles to test adaptability

7.3 Key Concepts and Terminologies

In this section, you will be introduced to the key concepts and terminologies commonly used in ma-
chine learning. Understanding these terms is crucial for anyone working in this field, as they form the
foundation of both theoretical and applied ML practices.

7.3.1 Features and Labels

In machine learning, features refer to the input variables or attributes that are used by the model to
make predictions. These can include any kind of data —numerical, categorical, or even textual — de-
pending on the problem being solved. Features are often represented as vectors or matrices and are
fed into the model to allow it to learn patterns from the data.
Labels, on the other hand, represent the target variable or the outcome that the model is trying to
predict. For supervised learning, the model uses labeled data (features paired with labels) to under-
stand the relationship between the inputs and the desired output. For example, in an image classifi-
cation task, the pixels of the image are the features, and the object category (e.g., "cat" or "dog") is the
label.
Feature Engineering is the process of transforming raw data into meaningful features that can
improve the performance of machine learning models. For instance, in natural language processing,
raw text is transformed into numerical vectors, such as word embeddings, that can be fed into models.

7.3.2 Training Data and Test Data

To evaluate a machine learning model’s performance accurately, the dataset is generally split into
training and test sets. The training data is used to train the model, meaning that the model learns
patterns from this subset by adjusting its internal parameters. The model must generalize well, i.e., it
must not simply memorize the training data but learn to make accurate predictions on unseen data.
92 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING

The test data, which the model has never seen during training, is used to evaluate its generalization
capabilities. This split ensures that the model is assessed on data it has not encountered before,
indicating how well it will perform on real-world, unseen datasets. Typically, an 80/20 or 70/30 split
between training and test data is used, although cross-validation techniques can provide a more robust
evaluation.
In addition to training and test data, a validation set is often used to tune hyperparameters and eval-
uate model performance during the training process. It helps prevent overfitting by providing feedback
on how well the model generalizes before it is exposed to the test data.

7.3.3 Model, Algorithm, and Hyperparameters

A model in machine learning refers to the mathematical structure or system that learns to make pre-
dictions or decisions based on data. For example, a linear regression model might predict numerical
outcomes based on a set of input features, while a convolutional neural network (CNN) might classify
images.
An algorithm refers to the process or method used to train the model. Common algorithms include
linear regression, decision trees, and gradient descent, among others. The algorithm defines how the
model updates its internal parameters based on the input data.
Hyperparameters are the external parameters that are not learned from the training data but are
set by the user. These include settings like learning rate, the number of layers in a neural network, or
the number of trees in a random forest. Proper tuning of hyperparameters is critical to optimizing a
model’s performance, and techniques such as grid search or Bayesian optimization are often used to
identify the best hyperparameters for a given task.
After training, models are evaluated using metrics such as accuracy, precision, recall, and the F1
score, depending on the problem type. For regression tasks, metrics like mean squared error (MSE) or
R-squared are commonly used. These metrics provide insight into how well the model is performing
on unseen data.

7.4 Machine Learning Process

Machine learning follows a structured and iterative process, involving several key stages that guide
the development and deployment of models. This section provides an overview of these stages, from
data collection to model deployment.

7.4.1 Data Collection

Data collection is the first step in the machine learning process. It involves gathering relevant and
high-quality data that will be used to train the model. The quality and quantity of the data directly
influence the performance of the model, making this step critical.
Sources of data can vary and include:

• Public datasets (e.g., from Kaggle, UCI Machine Learning Repository)

• APIs (e.g., Twitter API for text data)

• Custom collection from sensors, logs, or manual entry.

7.4. MACHINE LEARNING PROCESS 93

Key considerations during data collection include ensuring the data is relevant, representative, and
free of bias. In real-world projects, data collection is often one of the most time-consuming phases
due to the need for data cleaning and formatting before use.

7.4.2 Data Preprocessing

Once the data is collected, it undergoes preprocessing to prepare it for use by the machine learning
algorithm. Raw data is often incomplete, inconsistent, or noisy, making preprocessing a necessary
step to ensure quality input for the model.
Common preprocessing techniques include:

• Data Cleaning: Handling missing data (e.g., by imputing values), removing duplicates, and cor-
recting inconsistencies.

• Normalization and Standardization: Scaling numerical features so that they have a uniform
range or distribution, which improves the performance of many machine learning algorithms.

• Encoding Categorical Data: Converting categorical features into numerical values using tech-
niques like one-hot encoding or label encoding.

• Splitting the Data: Dividing the dataset into training, validation, and test sets to ensure that the
model generalizes well to unseen data.

7.4.3 Model Selection

Choosing the right model for a particular task depends on the nature of the problem and the data. This
process involves selecting a suitable algorithm that can learn from the data and perform well in the
target application.
Factors to consider when selecting a model include:

• Problem Type: Classification, regression, clustering, etc. For instance, decision trees, logistic
regression, and neural networks are common for classification tasks.

• Model Complexity: Simple models (like linear regression) are easier to interpret but may underfit
complex data, while more complex models (like deep neural networks) are powerful but prone
to overfitting.

• Data Size: Algorithms like k-nearest neighbors (KNN) can become computationally expensive
with large datasets, while models like stochastic gradient descent (SGD) can scale well.

• Training Time: Some algorithms (e.g., support vector machines) take more time to train, so
resource constraints must be considered.

7.4.4 Training and Evaluation

In the training phase, the model learns patterns from the training data by adjusting its internal pa-
rameters to minimize a predefined loss function. This process is typically iterative, involving multiple
epochs and optimization algorithms (e.g., gradient descent) that aim to find the best parameters.
Key elements of this stage include:
 94 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING

• Hyperparameter Tuning: Adjusting non-learnable parameters (e.g., learning rate, batch size) to
improve model performance. This is often done using grid search or randomized search.

• Cross-validation: A technique to assess the model’s performance and ensure that it generalizes
well. K-fold cross-validation is commonly used, where the data is split into multiple folds, and
the model is trained and tested on each fold.

• Evaluation Metrics: Different metrics are used to measure the model’s effectiveness, depending
on the problem. For classification tasks, accuracy, precision, recall, and F1-score are popular,
while for regression tasks, mean squared error (MSE) or R-squared is typically used.

7.4.5 Model Deployment and Monitoring

After a model has been trained and evaluated, the final step is deployment, where the model is inte-
grated into a production environment to make predictions on real-world data.
Key aspects of this phase include:

• Model Serving: Setting up infrastructure to expose the model as a service, often through APIs.
This allows other systems or applications to send new data to the model and receive predictions
in real time.

• Monitoring: Once deployed, continuous monitoring of the model is critical to ensure that it main-
tains its accuracy over time. Model drift (where the model’s performance deteriorates due to
changes in data patterns) is a common issue in production environments, requiring retraining or
adjustments to the model.

• Scalability: Ensuring that the model can handle increasing amounts of data or more requests
in real-time scenarios. Techniques like distributed computing or cloud-based deployment can
help.

7.5 Common Algorithms in Machine Learning

7.5.1 Linear Regression

Linear regression is one of the most fundamental algorithms in machine learning [68]. It is primarily
used for predictive analysis and finding relationships between variables. The equation for a simple
linear regression model can be written as:

y = β0 + β1 x + ϵ

Where y is the dependent variable, x is the independent variable, β0 is the intercept, β1 is the coefficient
(slope), and ϵ is the error term.
To implement linear regression in Python using PyTorch, you can follow this example:
1 import torch
2 import torch.nn as nn
3 import torch.optim as optim
4

5 # Sample data
6 x_train = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
 7.5. COMMON ALGORITHMS IN MACHINE LEARNING 95

7 y_train = torch.tensor([[2.0], [4.0], [6.0], [8.0]])

8

9 # Model definition
10 class LinearRegressionModel(nn.Module):
11 def __init__(self):
12 super(LinearRegressionModel, self).__init__()
13 self.linear = nn.Linear(1, 1)
14

15 def forward(self, x):

16 return self.linear(x)
17

18 model = LinearRegressionModel()
19

20 # Loss and optimizer

21 criterion = nn.MSELoss()
22 optimizer = optim.SGD(model.parameters(), lr=0.01)
23

24 # Training loop
25 for epoch in range(1000):
26 model.train()
27 optimizer.zero_grad()
28 outputs = model(x_train)
29 loss = criterion(outputs, y_train)
30 loss.backward()
31 optimizer.step()
32

33 if epoch % 100 == 0:
34 print(f'Epoch {epoch}, Loss: {loss.item()}')

Output:
Epoch 0, Loss: 44.164981842041016
Epoch 100, Loss: 0.10525545477867126
Epoch 200, Loss: 0.05778397619724274
Epoch 300, Loss: 0.03172262758016586
Epoch 400, Loss: 0.017415346577763557
Epoch 500, Loss: 0.009560829028487206
Epoch 600, Loss: 0.0052487668581306934
Epoch 700, Loss: 0.0028815295081585646
Epoch 800, Loss: 0.0015819233376532793
Epoch 900, Loss: 0.000868460105266422

This code defines a simple linear regression model using PyTorch, where we create a model, define
a loss function, and use gradient descent to optimize the model’s weights.

7.5.2 Logistic Regression

Logistic regression is used for binary classification problems. Unlike linear regression, it models the
probability that an observation belongs to a particular class by using the logistic function [37]:
1
P (y = 1|x) =
1 + e−(β0 +β1 x)
 96 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING

In PyTorch, a logistic regression model can be implemented similarly to linear regression but using a
sigmoid activation function for the output:

1 import torch.nn.functional as F
2

3 class LogisticRegressionModel(nn.Module):
4 def __init__(self):
5 super(LogisticRegressionModel, self).__init__()
6 self.linear = nn.Linear(1, 1)
7

8 def forward(self, x):

9 return torch.sigmoid(self.linear(x))
10

11 model = LogisticRegressionModel()

Here, the logistic function sigmoid is used to map outputs to probabilities between 0 and 1, suitable
for binary classification.

7.5.3 Decision Trees and Random Forests

Decision trees are non-parametric supervised learning algorithms used for classification and regres-
sion [55]. They split the data into subsets based on feature values to make predictions. Random
forests are an ensemble method that combines multiple decision trees to improve prediction accu-
racy [15].
In PyTorch, decision trees and random forests are not natively supported, but libraries like Scikit-
learn can be used to implement them:

1 from sklearn.ensemble import RandomForestClassifier

2

3 # Sample data
4 X_train = [[1, 2], [2, 3], [3, 4], [4, 5]]
5 y_train = [0, 1, 0, 1]
6

7 clf = RandomForestClassifier(n_estimators=10)
8 clf.fit(X_train, y_train)
9 print(clf.predict([[3, 3]]))

7.5.4 Support Vector Machines

Support Vector Machines (SVM) [24] are supervised learning models used for classification and re-
gression analysis. They work by finding a hyperplane that best separates the data into different classes.
Here is a simple example using Scikit-learn to implement an SVM:

1 from sklearn import svm

2

3 # Sample data
4 X_train = [[1, 2], [2, 3], [3, 4], [4, 5]]
5 y_train = [0, 1, 0, 1]
6
 7.6. CHALLENGES IN MACHINE LEARNING 97

7 clf = svm.SVC(kernel='linear')
8 clf.fit(X_train, y_train)
9 print(clf.predict([[3, 3]]))

7.5.5 Clustering Algorithms

Clustering algorithms, such as K-means [8], are used for unsupervised learning where the goal is to
group data into clusters based on similarity. K-means works by iteratively assigning data points to
clusters and adjusting the cluster centroids.
An example of K-means clustering with Scikit-learn:

1 from sklearn.cluster import KMeans

2

3 X = [[1, 2], [2, 3], [3, 4], [4, 5]]

4

5 kmeans = KMeans(n_clusters=2, random_state=0)

6 kmeans.fit(X)
7 print(kmeans.predict([[3, 3]]))

7.6 Challenges in Machine Learning

7.6.1 Overfitting and Underfitting

Overfitting occurs when a machine learning model learns the details and noise in the training data to
the extent that it negatively impacts the performance of new data. The model becomes too specific
and fails to generalize. Underfitting, on the other hand, happens when the model is too simple to
capture the underlying patterns of the data.
To mitigate overfitting, techniques such as cross-validation, regularization (L1, L2), and dropout (for
neural networks) are commonly used. Here’s an example of applying L2 regularization (also known as
weight decay) in PyTorch:

1 import torch.optim as optim

2

3 # Defining the optimizer with weight decay (L2 regularization)

4 optimizer = optim.SGD(model.parameters(), lr=0.01, weight_decay=1e-5)

For underfitting, the solution usually involves increasing model complexity, adding more features, or
training for longer periods.

7.6.2 Bias-Variance Tradeoff

The bias-variance tradeoff is a central challenge in machine learning. A model with high bias makes
strong assumptions about the data and tends to underfit, leading to poor performance on both the
training and testing data. In contrast, a model with high variance is too sensitive to the fluctuations in
the training data, leading to overfitting.
The goal is to find the right balance between bias and variance, which can be achieved through
model complexity tuning, regularization, and ensuring an appropriate amount of training data.
 98 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING

7.6.3 Data Quality and Quantity Issues

High-quality data is essential for machine learning models. Problems such as missing data, noisy data,
and imbalanced datasets can significantly degrade the performance of a model. Similarly, having an
insufficient quantity of data leads to difficulties in training models, often resulting in underfitting or
unstable models.
Techniques such as data augmentation, synthetic data generation, and balancing datasets using
methods like SMOTE (Synthetic Minority Over-sampling Technique) can help improve data quality and
quantity.
Here’s an example of how to handle missing data using Pandas:

1 import pandas as pd
2

3 # Filling missing values with the column mean

4 df.fillna(df.mean(), inplace=True)

7.6.4 Ethical Concerns and Bias in AI

Ethical issues in AI arise when models inadvertently encode biases present in the training data. This
bias can lead to unfair outcomes, particularly when the data reflects societal biases, such as racial or
gender discrimination.
Addressing these biases requires careful data curation, transparency in model design, and fairness-
aware algorithms that adjust for these biases. AI developers must be aware of these ethical concerns
to ensure their models are fair and just.

7.7 Machine Learning Tools and Libraries

7.7.1 Overview of Popular Libraries

There are several popular libraries used for machine learning, each offering different capabilities:
Scikit-learn: Primarily for classical machine learning algorithms such as linear regression, decision
trees, and clustering.
TensorFlow: A deep learning framework developed by Google that supports both CPU and GPU
computation, widely used in production environments.
PyTorch: Developed by Facebook, PyTorch is a deep learning library that is widely used in research
due to its dynamic computation graph, ease of use, and flexibility.
Here is how to import these libraries:

1 import sklearn
2 import tensorflow as tf
3 import torch

7.7.2 Choosing the Right Tool for Your Task

The choice of tool or library depends on the specific machine-learning task. For example: - If you are
working with traditional machine learning algorithms (like decision trees or clustering), Scikit-learn is
 7.8. PRACTICAL EXAMPLES AND CASE STUDIES 99

typically the best choice due to its simplicity. - For deep learning models, PyTorch or TensorFlow are
preferred. - TensorFlow is often chosen for large-scale production systems, while PyTorch is com-
monly used in research and development.

7.7.3 Integration with Data Processing Tools

Machine learning models often require substantial data processing before model training. Libraries
such as Pandas and NumPy are essential for data manipulation and preprocessing.
Here’s an example of using Pandas to load and preprocess a dataset:
1 import pandas as pd
2 import numpy as np
3

4 # Loading data
5 df = pd.read_csv('data.csv')
6

7 # Preprocessing: standardizing the data

8 df_standardized = (df - df.mean()) / df.std()

7.8 Practical Examples and Case Studies

7.8.1 Example Projects Using Supervised Learning

Supervised learning is commonly used in applications like spam detection, sentiment analysis, and
image classification. A classic example is predicting housing prices based on features such as size,
number of rooms, and location.
Here’s an example project where we use a simple linear regression model to predict housing prices:
1 # Assuming X_train, y_train contain the feature and label data
2 from sklearn.linear_model import LinearRegression
3

4 model = LinearRegression()
5 model.fit(X_train, y_train)
6 predictions = model.predict(X_test)

7.8.2 Unsupervised Learning in Action

Unsupervised learning is used in tasks where the goal is to uncover hidden patterns in data, such as
customer segmentation and anomaly detection. One common algorithm is K-means clustering, where
we cluster data points into a pre-specified number of groups.
Here’s how to apply K-means clustering to a dataset:
1 from sklearn.cluster import KMeans
2

3 kmeans = KMeans(n_clusters=3)
4 kmeans.fit(data)
5 labels = kmeans.predict(data)
 100 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING

7.8.3 Real-world Applications of Reinforcement Learning

Reinforcement learning is used in scenarios where an agent learns to take actions in an environment
to maximize cumulative reward. It is commonly applied in areas like robotics, game-playing, and au-
tonomous vehicles.
An example of reinforcement learning is Google’s AlphaGo, which uses this technique to play and
defeat human players in the game of Go. Reinforcement learning models like Q-learning are imple-
mented using PyTorch or TensorFlow, allowing the agent to learn optimal policies through trial and
error.
Here’s the basic structure of a Q-learning algorithm:

1 import numpy as np
2

3 # Initialize Q-table with zeros

4 Q_table = np.zeros([state_size, action_size])
5

6 # Update rule for Q-learning

7 def update_Q(Q_table, state, action, reward, next_state, alpha, gamma):
8 best_next_action = np.argmax(Q_table[next_state])
9 Q_table[state, action] = Q_table[state, action] + alpha * (reward + gamma * Q_table[next_state
, best_next_action] - Q_table[state, action])

7.9 Summary and Future Directions

7.9.1 Recap of Key Points

In this chapter, we covered the following important machine-learning concepts:

• We explored common algorithms in machine learning, such as linear regression, logistic regres-
sion, decision trees, random forests, support vector machines, and clustering algorithms.

• We discussed the key challenges faced in machine learning, including overfitting, underfitting,
bias-variance tradeoff, data quality, and ethical concerns related to bias in AI.

• We reviewed popular machine learning libraries such as Scikit-learn, TensorFlow, and PyTorch,
emphasizing how to choose the right tool for specific tasks.

• Practical case studies in supervised, unsupervised, and reinforcement learning were examined
to highlight real-world applications of these techniques.

Understanding these core topics prepares you for more advanced machine learning topics, where
these foundational algorithms and tools will be applied in increasingly complex scenarios.

7.9.2 Emerging Trends in Machine Learning

Machine learning is a rapidly evolving field, and new trends are constantly emerging. Some of the key
trends shaping the future of machine learning include:
7.9. SUMMARY AND FUTURE DIRECTIONS 101

AutoML: Automating machine learning processes has been a significant focus in recent years.
AutoML [28] tools allow non-experts to build machine learning models with minimal effort, automating
tasks such as feature engineering, model selection, and hyperparameter tuning.
Explainable AI (XAI): With the increasing adoption of machine learning in critical areas like health-
care and finance, there is a growing need for models that are interpretable and transparent. XAI fo-
cuses on creating models that can explain their decisions in ways humans can understand [7].
Federated Learning: Federated learning [62] is a technique that enables training models across
decentralized devices without needing to centralize data. This approach enhances data privacy and
security, making it suitable for industries like healthcare and finance.
Deep Reinforcement Learning: Reinforcement learning combined with deep learning techniques
has been making headlines due to its success in areas such as robotics, game AI, and autonomous
driving. This trend is expected to grow as more real-world applications are explored.
AI Ethics and Fairness: As machine learning becomes more embedded in society, there is a grow-
ing focus on ensuring that AI systems are fair, transparent, and ethical. Regulatory frameworks are
being developed to ensure the responsible deployment of AI technologies [65].

7.9.3 Further Reading and Resources

To deepen your understanding of machine learning, consider exploring the following books, articles,
and online resources:
Books:

• Pattern Recognition and Machine Learning by Christopher M. Bishop — A comprehensive intro-

duction to the concepts of machine learning, suitable for advanced learners.

• Deep Learning by Ian Goodfellow, Yoshua Bengio, and Aaron Courville — An in-depth guide to
deep learning, covering foundational concepts and modern applications.

Articles:

• "A Few Useful Things to Know About Machine Learning" by Pedro Domingos — A well-known
article that covers essential tips for practitioners in the field.

• "Deep Learning for AI" by Yann LeCun, Yoshua Bengio, and Geoffrey Hinton — A foundational
paper on deep learning that outlines the concepts driving this field.

Online Resources:

• Coursera: Machine Learning by Andrew Ng — A popular course that provides an excellent intro-
duction to the field of machine learning.

• Fast.ai: Practical deep learning for coders — A hands-on course designed to teach deep learning
with PyTorch.

• Kaggle: An online platform where you can participate in machine learning competitions, learn
from other practitioners, and work on real-world datasets.
102 CHAPTER 7. INTRODUCTION TO MACHINE LEARNING
Chapter 8

Understanding Neural Networks

8.1 Introduction to Neural Networks

Neural networks (NN), central to deep learning, are computational models inspired by the structure
and functioning of the human brain. Each neural network consists of interconnected layers of artificial
neurons, which process and transmit information. The foundation of neural networks lies in their ability
to learn complex patterns from data, enabling them to perform tasks like image recognition, language
translation, and decision-making with unprecedented accuracy.
Neural networks have become indispensable in modern machine learning because they can ap-
proximate any continuous function, making them highly versatile in solving both linear and nonlin-
ear problems. They excel in domains with large amounts of data, where traditional algorithms might
struggle to capture intricate relationships between features. For example, deep learning models, par-
ticularly those based on neural networks, have set new benchmarks in fields like speech recognition,
autonomous driving, and medical diagnosis.

8.2 The Perceptron

8.2.1 Mathematical Foundations of the Perceptron

The perceptron, introduced by Frank Rosenblatt in 1958 [86], is the simplest form of a neural net-
work. Mathematically, it consists of an input vector X = (x1 , x2 , . . . , xn ), corresponding weights
W = (w1 , w2 , . . . , wn ), a bias term b, and an activation function ϕ. The output of the perceptron is
computed as:

y = ϕ(W · X + b),

where ϕ is often a step function (Heaviside function) that outputs a binary decision based on
whether the weighted sum is greater than a threshold.
This model can be visualized as a single neuron in which input data is passed through the weighted
sum and bias, followed by an activation function. Despite its simplicity, the perceptron is capable of
solving linearly separable problems, such as classifying points on opposite sides of a line in a 2D
space.

103
104 CHAPTER 8. UNDERSTANDING NEURAL NETWORKS

8.2.2 Limitations of the Perceptron

The primary limitation of the perceptron is its inability to solve non-linearly separable problems, such
as the XOR problem. The XOR operation, which outputs true only when inputs differ, cannot be rep-
resented by a single linear decision boundary. This limitation was famously demonstrated by Minsky
and Papert in 1969 [64], which led to a decline in neural network research until the advent of multi-layer
perceptrons (MLPs) and backpropagation algorithms.
By introducing hidden layers between the input and output, the MLP overcomes this limitation.
These hidden layers allow for the creation of more complex decision boundaries, making neural net-
works capable of solving more intricate problems.

8.3 Multilayer Perceptrons (MLP)

8.3.1 Architecture of MLP

The Multilayer Perceptron (MLP) is a class of feedforward artificial neural networks that consists of
at least three layers: an input layer, one or more hidden layers, and an output layer. Each layer contains
fully connected neurons. MLP learns by adjusting the weights of these connections during training.
The key advantage of MLPs over simpler models like single-layer perceptrons is their ability to
model complex, non-linear relationships in data. The addition of hidden layers allows MLPs to capture
intricate patterns through hierarchical feature extraction. Each hidden layer transforms the input data
in ways that make it easier for the subsequent layer to classify or predict.
During the learning process, MLPs use backpropagation, an algorithm that computes the gradient
of the loss function concerning each weight by employing the chain rule. This allows the network to
iteratively update weights in the direction that minimizes the error, enhancing the model’s accuracy
and robustness.

8.3.2 Activation Functions

A critical aspect of the MLP’s power lies within its activation functions, which introduce non-linearity
into the NN. Without non-linear activation functions, the MLP would essentially behave like a linear
regression model, rendering it incapable of solving complex tasks. Common activation functions in-
clude:
Sigmoid Function The sigmoid function [71], defined as σ(x) = 1+e−x ,
1
outputs values between 0
and 1, making it useful for binary classification tasks. However, sigmoid suffer from vanishing gradi-
ents, which can slow down learning in deeper networks. This makes it less commonly used in modern
deep-learning architectures.
ex −e−x
Hyperbolic Tangent (Tanh) The tanh function, defined as tanh(x) = ex +e−x , produces outputs
between -1 and 1. Like the sigmoid, tanh also faces vanishing gradient issues, though it tends to work
better than sigmoid in practice as its outputs are zero-centered, allowing for a more balanced gradient
flow.
Rectified Linear Unit (ReLU) ReLU [2], defined as ReLU(x) = max(0, x), has become the most
popular activation function for hidden layers. It mitigates the vanishing gradient problem by maintain-
ing gradients for positive values of x, allowing for faster and more efficient training of deep networks.
However, ReLU can suffer from "dead neurons" where gradients become zero for negative inputs, which
makes variants like Leaky ReLU and Parametric ReLU useful in some scenarios.
8.4. FEEDFORWARD NEURAL NETWORKS 105

Softmax For classification tasks involving multiple categories, the softmax function is often used in
the output layer. It converts the raw output of the network into a probability distribution, ensuring that
the sum of all outputs equals one. This is particularly useful in multi-class classification problems [77].
Each activation function has its specific use case, and the choice of function depends on the nature
of the problem being solved, the depth of the network, and the computational resources available. The
selection of the activation function also affects the speed and stability of model convergence during
training.

8.4 Feedforward Neural Networks

Feedforward Neural Networks (FNN) are the simplest form of artificial neural networks, where infor-
mation moves in one direction—from the input layer through the hidden layers (if any) to the output
layer. Unlike recurrent networks, there are no cycles or feedback loops in FNNs. This makes them ideal
for tasks like classification, regression, and function approximation, where the goal is to map inputs
to outputs in a structured, linear manner.

8.4.1 Forward Propagation

Forward propagation is the process by which data flows through the network during both training and
inference. In this process, the input data is multiplied by the corresponding weights and then passed
through an activation function. This happens layer by layer, with the information being transformed at
each hidden layer until it reaches the output layer.
Mathematically, for each neuron i in a given layer l, the output is computed as:
(l) (l) (l−1) (l)
X
zi = wij xj + bi
j

(l) (l−1) (l)

where wij are the weights, xj is the input from the previous layer, and bi is the bias term for
(l)
that neuron. This weighted sum zi is then passed through an activation function f , typically ReLU,
sigmoid, or tanh, to introduce non-linearity:
(l) (l)
ai = f (zi )

This process repeats for every layer until the final output is produced at the output layer.

8.4.2 Loss Functions and Objective Functions

Loss functions are essential in quantifying how well a model’s predicted outputs match the actual
targets. The loss function calculates the error between the predicted output and the true label, serving
as the objective function to be minimized during training.
Common Loss Functions:
Mean Squared Error (MSE): Used for regression tasks, it calculates the average squared difference
between predicted and true values. Mathematically, it is expressed as:
N
1 X
MSE = (yi − yˆi )2
N i=1

where yi is the actual value and yˆi is the predicted value.

106 CHAPTER 8. UNDERSTANDING NEURAL NETWORKS

Cross-Entropy Loss: Primarily used for classification tasks, cross-entropy measures the difference
between the true probability distribution and the predicted one. For binary classification, it is defined
as:
N
1 X
Cross-Entropy = − [yi log(yˆi ) + (1 − yi ) log(1 − yˆi )]
N i=1

Cross-entropy penalizes confident but incorrect predictions more heavily, making it effective for clas-
sification models.
The gradients of the loss function concerning the model’s parameters are calculated and used to
update the weights via optimization algorithms like gradient descent or its variants. Minimizing the
loss function over multiple iterations ensures that the model improves its predictions by learning the
optimal set of weights.

8.5 Backpropagation and Gradient Descent

8.5.1 Gradient Descent Algorithm

Gradient Descent [107] is an optimization technique used to minimize the cost function of a neural
network by iteratively adjusting the model’s parameters (weights and biases). The core idea is to
move in the direction of the negative gradient of the cost function to find the global or local minimum.
Mathematically, it updates each parameter w by:

∂J(w)
w := w − η
∂w
∂J(w)
where η is the learning rate, and ∂w is the gradient of the cost function concerning the weight
w. The learning rate determines the size of the step we take toward the minimum; if it’s too large, the
algorithm may overshoot, and if it’s too small, convergence will be slow.

8.5.2 Backpropagation Algorithm

Backpropagation is the key algorithm used to compute the gradients needed for gradient descent in a
neural network. It works by calculating the gradient of the loss function concerning each weight, and
iteratively adjusting weights to minimize the error. This is achieved using the chain rule to propagate
errors backward from the output layer to the input layer.
Steps of Backpropagation

• Forward Pass: Input data is passed through the network layer by layer, computing activation until
the output is produced. The loss function J(ŷ, y) is calculated based on the difference between
the predicted output ŷ and the true output y.

• Backward Pass: The partial derivatives of the loss function concerning the weights are calcu-
lated. Using the chain rule, we can compute the gradient of the cost function for each layer
starting from the output:
∂J ∂J ∂ ŷ ∂z
= · ·
∂w ∂ ŷ ∂z ∂w
where z is the weighted input to the neuron, and ŷ is the predicted output.
8.6. WEIGHT INITIALIZATION AND REGULARIZATION 107

• Weight Update: The gradients are used to update the weights, moving them in the direction that
minimizes the loss function:
∂J
w′ = w − η
∂w
This process is repeated for multiple training epochs until the network converges to a minimal loss.

8.5.3 Optimization Techniques (SGD, Adam, etc.)

Several variations of the gradient descent algorithm have been developed to improve convergence and
performance:
Stochastic Gradient Descent (SGD)
SGD updates the model parameters using a single training example at each iteration, rather than
calculating the gradient over the entire dataset. This makes SGD much faster for large datasets but
introduces more variance in updates, leading to a noisier convergence:
∂J(w) (i) (i)
w′ = w − η (x , y )
∂w
where x(i) , y (i) represents one training example.
Adam (Adaptive Moment Estimation)
Adam [49] is a more advanced optimization algorithm that adapts the learning rate for each param-
eter. It combines the benefits of both AdaGrad (adaptive learning rates) and RMSProp (exponentially
decaying average of past gradients). Adam maintains two moving averages of the gradient (first and
second moments) to scale the learning rate:

mt = β1 mt−1 + (1 − β1 )gt

vt = β2 vt−1 + (1 − β2 )gt2

where gt is the gradient at time step t, and β1 , β2 are decay rates. The adaptive learning rate makes
Adam particularly effective for non-stationary and noisy objectives.

8.6 Weight Initialization and Regularization

8.6.1 Importance of Weight Initialization

Proper weight initialization is essential for efficient training of deep neural networks. If the weights
are too large or too small, it can lead to issues such as vanishing or exploding gradients, which can
severely slow down or even prevent model convergence. Two commonly used initialization techniques
are:

Xavier Initialization:

This method is used primarily for networks with sigmoid or tanh activation functions [32]. It ensures
that the variance of the outputs of each layer remains constant by drawing the initial weights from a
distribution with variance:
1
v2 =
N
where N is the number of input neurons to the layer. This helps to prevent the gradients from becoming
too small as they propagate through the network.
108 CHAPTER 8. UNDERSTANDING NEURAL NETWORKS

He Initialization:

For ReLU and its variants, He initialization is more appropriate [38]. It adjusts the variance of the
weights to:
2
v2 =
N
where N is the number of inputs to the neuron. This helps maintain variance throughout the network,
allowing for faster convergence, especially in deep networks.

8.6.2 Overfitting and Regularization

Overfitting occurs when a model performs well on the training data but poorly on unseen data. Regu-
larization techniques help to reduce overfitting by penalizing overly complex models, encouraging the
network to generalize better to new data.

L1 and L2 Regularization

L1 Regularization (Lasso): L1 regularization [17] adds a penalty proportional to the absolute value of
the weights:
X
J = J0 + λ |wi |

This encourages sparsity in the network by driving some weights to zero, which can be useful for
feature selection.

L2 Regularization (Ridge or Weight Decay): L2 regularization [40] adds a penalty proportional to the
square of the weights:
X
J = J0 + λ wi2

L2 regularization tends to shrink all weights but does not force them to zero, promoting smoother,
more distributed weight values. It helps in stabilizing learning and preventing large swings in weights
during training.

Dropout

Dropout [94] is a widely used regularization technique that works by randomly "dropping" a subset of
neurons during each training iteration. Each neuron is kept active with a probability p (a hyperparam-
eter typically between 0.5 and 0.8). This prevents the network from relying too heavily on any single
neuron and forces it to learn more robust features. During inference, the full network is used, but the
weights are scaled to account for the dropped neurons during training.

8.7 Convolutional Neural Networks (CNNs)

8.7.1 Introduction to CNNs

Convolutional Neural Networks (CNNs) [74] are a specialized class of neural networks designed to
process data with a grid-like topology, such as images. CNNs have revolutionized fields like image
recognition, computer vision, and video analysis due to their ability to automatically and efficiently
extract spatial hierarchies of features. CNNs reduce the need for manual feature extraction by learning
both low-level features like edges and high-level features like shapes during training.
8.7. CONVOLUTIONAL NEURAL NETWORKS (CNNS) 109

CNNs differ from traditional feedforward neural networks in their architecture, utilizing convo-
lutional layers instead of fully connected layers. This enables the network to be more parameter-
efficient, making it better suited for high-dimensional inputs such as images, which can contain mil-
lions of pixels. CNNs are widely used in applications such as object detection, facial recognition,
medical imaging, and even natural language processing when processing structured data.

8.7.2 Convolutional Layers and Pooling

The core component of CNNs is the convolutional layer. In a convolutional layer, small filters (or ker-
nels) slide over the input data, performing element-wise multiplications and summing the results to
produce feature maps. Each filter is responsible for detecting different features, such as edges, tex-
tures, or more complex patterns, depending on the layer’s depth in the network.
Mathematically, for an input feature map I and a filter F , the convolution operation is defined as:
XX
S(i, j) = (I ∗ F )(i, j) = I(i + m, j + n)F (m, n)
m n

where S(i, j) is the result of the convolution at position (i, j), and m, n are the dimensions of the filter.
Convolutional layers are often followed by non-linear activation functions like ReLU (Rectified Lin-
ear Unit), which introduce non-linearity into the model and allow it to learn more complex representa-
tions.

Pooling Layers:

Pooling layers are another essential part of CNNs, typically used after convolutional layers to reduce
the spatial dimensions of the feature maps, which helps decrease the number of parameters and
computational complexity. The most common form of pooling is max pooling, where a filter selects
the maximum value from a region of the feature map. Mathematically, max pooling for a 2x2 region
can be described as:

P (i, j) = max{S(i, j), S(i + 1, j), S(i, j + 1), S(i + 1, j + 1)}

Pooling helps retain the most important information while discarding less relevant details, making the
network more robust to minor translations and distortions in the input data.

8.7.3 Applications of CNNs

CNNs have found widespread applications due to their strong ability to process visual data:

• Image Classification: CNNs are used to classify images, from basic object recognition to more
complex tasks like identifying tumors in medical imaging [54].

• Object Detection: Advanced CNN architectures such as Faster R-CNN [83] and YOLO (You Only
Look Once) [82] enable real-time object detection and localization in images and videos.

• Facial Recognition: CNNs are used in facial recognition systems, where they extract unique
features from faces for identification and verification purposes [98].

• Medical Imaging: In the healthcare sector, CNNs are utilized to analyze medical images such as
X-rays, MRIs, and CT scans to detect diseases and abnormalities [90].
110 CHAPTER 8. UNDERSTANDING NEURAL NETWORKS

• Natural Language Processing: While CNNs are primarily used for image-related tasks, they are
also applied in NLP for tasks like sentence classification by treating text as a structured grid [48].

The combination of convolutional layers for feature extraction and pooling layers for dimension-
ality reduction makes CNNs highly effective for handling large-scale image data and other spatially
structured data, making them a cornerstone of modern machine learning.

8.8 Recurrent Neural Networks (RNNs) and Variants

8.8.1 Introduction to RNNs

Recurrent Neural Networks (RNNs) [88] are a class of neural networks designed to model sequential
data by maintaining a memory of previous inputs. Unlike feedforward networks, RNNs allow informa-
tion to persist, making them well-suited for tasks involving sequences, such as time series prediction,
natural language processing, and speech recognition. The key feature of RNNs is their use of loops in
the network, enabling the network to pass information from one step to the next.
Mathematically, the hidden state ht at time step t is computed based on the input xt and the hidden
state from the previous time step ht−1 :

ht = f (Wxh xt + Whh ht−1 + bh )

where Wxh and Whh are weight matrices, bh is the bias, and f is the activation function (typically tanh
or ReLU).
While RNNs excel at capturing temporal dependencies, they struggle with long-term dependencies
due to issues like vanishing and exploding gradients. This led to the development of more advanced
architectures like LSTMs and GRUs.

8.8.2 Long Short-Term Memory (LSTM)

Long Short-Term Memory (LSTM) networks [39] is a type of RNN specifically designed to handle long-
term dependencies in sequential data. LSTMs mitigate the vanishing gradient problem by introducing
a memory cell Ct that retains information across many time steps. Each LSTM unit contains three
gates: the forget gate, input gate, and output gate, which control the flow of information into and out
of the cell.
The equations governing an LSTM cell at time step t are as follows:

ft = σ(Wf · [ht−1 , xt ] + bf )

it = σ(Wi · [ht−1 , xt ] + bi )

C̃t = tanh(WC · [ht−1 , xt ] + bC )

Ct = ft ∗ Ct−1 + it ∗ C̃t

ot = σ(Wo · [ht−1 , xt ] + bo )

ht = ot ∗ tanh(Ct )

Here, ft , it , and ot represent the forget, input, and output gates, respectively, while Ct is the cell state.
The LSTM architecture allows the network to retain information over long sequences, making it ideal
for tasks like language modeling, machine translation, and video analysis.
8.9. ADVANCED NEURAL NETWORK ARCHITECTURES 111

8.8.3 Gated Recurrent Units (GRU)

Gated Recurrent Units (GRUs) [22] is another variant of RNNs, similar to LSTMs but with a simplified
architecture. GRUs combine the forget and input gates into a single update gate and merge the cell
state with the hidden state. This results in fewer parameters and a faster training process compared
to LSTMs, while still retaining the ability to capture long-term dependencies.
The key equations for a GRU are:

zt = σ(Wz · [ht−1 , xt ] + bz )

rt = σ(Wr · [ht−1 , xt ] + br )

h̃t = tanh(Wh · [rt ∗ ht−1 , xt ] + bh )

ht = zt ∗ ht−1 + (1 − zt ) ∗ h̃t

Here, zt is the update gate and rt is the reset gate. GRUs are particularly useful for time series analysis,
speech recognition, and tasks where computational efficiency is important.

8.8.4 Applications of RNNs, LSTMs, and GRUs

RNNs and their variants are widely used across domains that require sequential data modeling. Com-
mon applications include:

• Natural Language Processing: RNNs, LSTMs, and GRUs are used for tasks such as language
translation, text generation, and sentiment analysis.

• Time Series Prediction: RNNs are applied to financial forecasting, weather prediction, and stock
market analysis.

• Speech Recognition: LSTMs and GRUs are employed in speech-to-text systems to capture tem-
poral dependencies in audio signals.

• Video Analysis: These architectures are used to analyze sequential frames in video data, en-
abling tasks like action recognition and video captioning.

8.9 Advanced Neural Network Architectures

8.9.1 Autoencoders
Autoencoders [10] are a type of unsupervised neural network architecture designed to learn efficient
codings of input data. The network consists of two main parts: the encoder, which compresses the
input data into a latent representation, and the decoder, which reconstructs the original data from
this representation. Autoencoders are commonly used for tasks such as dimensionality reduction,
anomaly detection, and data denoising.
The architecture of an autoencoder can be represented as follows:

h = f (We · x + be )

x̂ = g(Wd · h + bd )
112 CHAPTER 8. UNDERSTANDING NEURAL NETWORKS

where x is the input, h is the encoded representation, and x̂ is the reconstructed input. The goal of
training an autoencoder is to minimize the difference between x and x̂, typically using a loss function
like mean squared error (MSE).
Variational Autoencoders (VAEs) are an extension of basic autoencoders that introduce a prob-
abilistic approach to the latent space, allowing for more meaningful interpolation and generation of
new data samples.

8.9.2 Generative Adversarial Networks (GANs)

Generative Adversarial Networks (GANs) [33] consist of two neural networks that compete with each
other in a game-like scenario: the generator and the discriminator. The generator creates synthetic
data samples, while the discriminator tries to distinguish between real and generated data. The goal
of the generator is to fool the discriminator by producing data that is indistinguishable from real data.
The generator learns by minimizing the following loss function:

LG = − log(D(G(z)))

where G(z) is the generator’s output given noise input z, and D is the discriminator’s prediction.
GANs are widely used in tasks such as image generation, video synthesis, and style transfer. Vari-
ants like Deep Convolutional GANs (DCGANs) and Conditional GANs (CGANs) have expanded their
application scope, allowing for more controlled and realistic data generation.

8.9.3 Transformers
Transformers [99] are a type of neural network architecture designed to handle sequential data without
relying on recurrent layers. Instead, they use a mechanism called self-attention, which allows the
model to weigh the importance of different parts of the input sequence. This makes Transformers
particularly effective for tasks involving long-range dependencies.
The self-attention mechanism can be expressed as:

QK T
 
Attention(Q, K, V ) = softmax √ V
dk

where Q (queries), K (keys), and V (values) are the inputs, and dk is the dimension of the key vectors.
Transformers are widely used in natural language processing tasks, particularly for sequence-to-
sequence tasks such as language translation and text summarization. The architecture was popu-
larized by models like BERT and GPT, which have set new benchmarks in NLP by leveraging massive
pre-trained models and fine-tuning them for specific tasks.

8.9.4 Applications of Advanced Neural Architectures

• Autoencoders: Used for anomaly detection, data compression, and generative tasks like image
denoising and inpainting.

• GANs: Applied in image and video generation, deepfake technology, and creative AI systems for
art generation.

• Transformers: Power state-of-the-art language models, machine translation systems, and question-
answering tasks.
8.10. HYPERPARAMETER TUNING 113

8.10 Hyperparameter Tuning

8.10.1 Common Hyperparameters

Hyperparameter tuning is a critical step in improving model performance and ensuring generalization
to unseen data. Hyperparameters are settings that must be specified before the learning process
begins, and they directly influence the behavior of the training process and the capacity of the model.
Some of the most important hyperparameters include:

Learning Rate:

The learning rate determines the size of the steps taken during gradient descent to minimize the loss
function. A low learning rate results in slow convergence, while a high learning rate can cause the
model to overshoot the optimal values, leading to divergence. Optimizing this hyperparameter is es-
sential for training efficiency and stability.

Batch Size:

Batch size defines how many samples are processed before the model’s internal parameters (weights)
are updated. Small batch sizes can introduce noise into gradient estimates but often lead to faster
convergence. Larger batch sizes provide more stable gradients but require more memory and can lead
to slower updates.

Number of Layers and Neurons:

The architecture of a neural network, such as the number of layers and the number of neurons per
layer, defines its capacity to learn complex patterns. More layers and neurons can capture higher-level
abstractions but may also lead to overfitting if not controlled through regularization.

Dropout Rate:

Dropout is a regularization technique where randomly selected neurons are ignored during training
to prevent overfitting. The dropout rate specifies the probability of dropping a neuron in each layer.
Adjusting this hyperparameter can significantly affect the generalization ability of the model.

Weight Initialization:

Proper weight initialization can prevent issues such as vanishing and exploding gradients. Techniques
like Xavier or He initialization are commonly used to ensure that the variance of activations is consis-
tent across layers, allowing for smoother learning.

Optimizer:

The choice of the optimizer (e.g., Stochastic Gradient Descent, Adam, RMSprop) controls how the
model’s parameters are updated based on the gradients. Some optimizers are better suited for spe-
cific tasks or architectures, and tuning their hyperparameters (e.g., momentum, beta parameters) can
improve convergence.
114 CHAPTER 8. UNDERSTANDING NEURAL NETWORKS

8.10.2 Grid Search, Random Search, and Bayesian Optimization

There are several methods to optimize hyperparameters. The following techniques are commonly
used to find the best hyperparameter configurations:

Grid Search:

Grid search is an exhaustive method for hyperparameter tuning where all possible combinations of
a predefined set of hyperparameter values are evaluated. While it guarantees finding the best com-
bination, grid search can be computationally expensive, especially when dealing with multiple hyper-
parameters or large models. It works best when the search space is small or when computational
resources are abundant.

Random Search:

In random search, hyperparameters are randomly sampled from predefined distributions. Unlike grid
search, random search does not systematically test all combinations, but it often finds good solutions
faster because it covers a wider range of the hyperparameter space. Empirical studies have shown that
random search can be more efficient than grid search for high-dimensional hyperparameter spaces.

Bayesian Optimization:

Bayesian optimization [93] models the relationship between hyperparameters and the model’s perfor-
mance as a probabilistic function. It selects hyperparameter settings based on previous evaluations,
balancing exploration (trying new regions of the hyperparameter space) with exploitation (focusing on
promising areas). This approach is more efficient than grid or random search, particularly for complex
models with many hyperparameters. Bayesian optimization is ideal when computational resources are
limited or when training is time-consuming.

Choosing an Optimization Method

The choice of hyperparameter optimization method depends on the complexity of the model and the
available computational resources:

• Grid Search: Suitable for small models and when all hyperparameter values need to be tested.

• Random Search: More practical for larger search spaces where only a subset of hyperparameter
combinations need to be evaluated.

• Bayesian Optimization: Best suited for models where each evaluation is computationally expen-
sive, and an informed search is necessary to optimize quickly.

8.11 Practical Considerations

8.11.1 Hardware Requirements for Training Neural Networks

Training neural networks, particularly deep learning models, requires specialized hardware to handle
the high computational demands. The primary options for hardware include:
8.11. PRACTICAL CONSIDERATIONS 115

Graphics Processing Units (GPUs):

GPUs are widely used for training neural networks due to their ability to perform parallel computa-
tions efficiently. They are particularly effective for tasks involving large datasets and models such as
Convolutional Neural Networks (CNNs) and Recurrent Neural Networks (RNNs). High-end GPUs, such
as the NVIDIA A100, are ideal for large-scale deep-learning tasks, offering high throughput for both
training and inference.

Tensor Processing Units (TPUs):

TPUs, developed by Google [45], are specialized hardware designed for machine learning tasks. TPUs
are highly optimized for tensor operations and provide even faster performance than GPUs for certain
tasks, such as training large transformer models and CNNs. TPUs are particularly suited for projects
deployed on Google Cloud, where they can be scaled easily for large datasets and complex models.

Memory and Storage:

Training large neural networks requires substantial memory resources. Models with millions or billions
of parameters demand high VRAM (16GB to 40GB or more) to prevent memory bottlenecks. Fast
storage solutions such as NVMe SSDs are critical for loading large datasets quickly, especially when
performing data-intensive tasks like training on large image or text corpora.

8.11.2 Training and Inference Speed Considerations

Training and inference speed depend heavily on the hardware used and the optimization of the neural
network architecture. Key considerations include:

Batch Size and Learning Rate:

Batch size and learning rate are critical hyperparameters that influence training speed. Larger batch
sizes reduce the variance in gradient updates but require more memory. The learning rate controls the
speed of convergence, and optimizing this can prevent unnecessary training epochs.

Model Parallelism and Data Parallelism:

For very large models, such as those used in NLP (e.g., GPT-3), it is common to use parallelism strate-
gies. Model parallelism splits the model across multiple devices, while data parallelism distributes
the training data across multiple devices. These techniques are essential for scaling models across
multiple GPUs or TPUs to accelerate training.

Inference Optimization:

For inference tasks, it is essential to minimize latency. Optimizations like pruning, quantization, and
model compression reduce the size of the model, making inference faster and more efficient, espe-
cially when deploying models on edge devices or in production environments with limited resources.
116 CHAPTER 8. UNDERSTANDING NEURAL NETWORKS

8.11.3 Model Deployment and Scalability

Once a model is trained, deploying it effectively requires careful consideration of the deployment en-
vironment and scalability. Key aspects include:

Scalability:

In large-scale applications, such as recommendation systems or real-time analytics, the ability to scale
neural network models across multiple devices or cloud platforms is essential. TPUs, particularly
in Google Cloud environments, offer seamless scalability for deep learning tasks. For GPU-based
deployments, frameworks like NVIDIA’s TensorRT help optimize models for different GPUs, enhancing
inference speed and performance.

Deployment in Cloud Environments:

Cloud platforms like AWS, Google Cloud, and Azure provide flexible and scalable environments for
deploying machine learning models. These platforms offer pre-configured instances with GPUs or
TPUs, enabling rapid scaling as demand increases. Leveraging serverless functions and containerized
services (e.g., Kubernetes) allows for dynamic scaling of machine learning services.

Edge Deployment and Energy Efficiency:

For applications like autonomous vehicles and IoT devices, deploying models on edge devices is es-
sential. Accelerators such as Edge TPUs and mobile GPUs offer efficient deployment solutions by
optimizing models for lower power consumption and real-time processing.

Monitoring and Maintenance:

After deployment, it is crucial to monitor model performance in production environments. Continuous

integration with MLOps frameworks ensures models are retrained and updated as needed, maintaining
high accuracy and efficiency over time.
Chapter 9

Getting Started with Deep Learning

9.1 AI Environment Setup

In this section, we will go through the necessary steps to set up your environment for deep learning
tasks. Whether you are using a CPU or a GPU, having the correct libraries and tools installed is essential
for the smooth development and execution of machine learning models.

9.1.1 Installing Deep Learning Libraries

To get started with deep learning, you’ll need to install the necessary Python libraries. The two most
popular libraries for deep learning are TensorFlow and PyTorch. Here’s how you can install them using
pip, Python’s package installer:
Installing TensorFlow:

pip install tensorflow

Installing PyTorch: The installation command for PyTorch depends on your system configuration
(CPU or GPU). You can specify these options on the official PyTorch website (https://pytorch.org/).
For example, to install PyTorch with CUDA (for NVIDIA GPU support):

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

Setting up Virtual Environments: It’s highly recommended to create a virtual environment for your
deep learning projects. This helps you manage dependencies and avoid conflicts between different
projects. Here’s how to set up a virtual environment:

# Install virtualenv if not already installed

pip install virtualenv

# Create a virtual environment (replace 'env_name' with your chosen name)

virtualenv env_name

# Activate the virtual environment

# For Windows:
env_name\Scripts\activate
# For macOS/Linux:
source env_name/bin/activate

117
 118 CHAPTER 9. GETTING STARTED WITH DEEP LEARNING

# Install deep learning libraries inside the virtual environment

pip install tensorflow
pip install torch

Remember to always activate the virtual environment before working on your project, and deacti-
vate it after finishing your session by running:

deactivate

9.1.2 GPU Setup for Deep Learning

Deep learning models can benefit greatly from GPU acceleration, especially when working with large
datasets and complex models. NVIDIA GPUs are commonly used for deep learning tasks because
they support CUDA, a parallel computing platform, and cuDNN, a library for deep neural networks.
Installing CUDA and cuDNN: To leverage GPU acceleration in TensorFlow or PyTorch, you’ll need
to set up CUDA and cuDNN. Follow these steps:

1. Download and install the NVIDIA drivers for your GPU from https://www.nvidia.com/drivers.

2. Download CUDA from https://developer.nvidia.com/cuda-downloads. Select the version com-

patible with your GPU and operating system.

3. Download cuDNN from https://developer.nvidia.com/cudnn. You’ll need to register for a free

NVIDIA Developer account to access the download.

4. After installing CUDA, copy the cuDNN files to the appropriate directories:

# Copy cuDNN files to the CUDA directory

cp <cuDNN_path>/libcudnn* <CUDA_path>/lib64/
cp <cuDNN_path>/include/cudnn*.h <CUDA_path>/include/

For a more detailed setup guide, refer to the official documentation:

• CUDA Installation Guide: https://docs.nvidia.com/cuda/

• cuDNN Installation Guide: https://docs.nvidia.com/deeplearning/cudnn/

Once CUDA and cuDNN are installed, you can verify that PyTorch is using the GPU by running the
following Python code:

1 import torch
2 if torch.cuda.is_available():
3 print("CUDA is available. PyTorch is using GPU!")
4 else:
5 print("CUDA is not available. PyTorch is using CPU.")

Similarly, for TensorFlow, you can verify GPU availability with:

1 import tensorflow as tf
2 print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))
 9.2. INTRODUCTION TO TENSORFLOW AND PYTORCH 119

9.2 Introduction to TensorFlow and PyTorch

9.2.1 Overview of TensorFlow

TensorFlow is an open-source deep learning framework developed by Google. It is widely used for
both research and production environments, offering a flexible architecture for building and deploying
machine learning models. The TensorFlow ecosystem includes tools like TensorFlow Extended (TFX)
for deploying ML pipelines, TensorFlow Lite for mobile and embedded devices, and TensorFlow.js
for running ML models in the browser.
One of the main features of TensorFlow is the use of computational graphs. This allows for opti-
mization across a wide range of hardware devices, such as CPUs, GPUs, and TPUs.
Basic Neural Network in TensorFlow: The following example demonstrates how to create a simple
feedforward neural network using TensorFlow’s Keras API:

1 import tensorflow as tf
2 from tensorflow.keras import layers
3

4 # Define a simple neural network model

5 model = tf.keras.Sequential([
6 layers.Dense(128, activation='relu', input_shape=(784,)),
7 layers.Dense(64, activation='relu'),
8 layers.Dense(10, activation='softmax')
9 ])
10

11 # Compile the model

12 model.compile(optimizer='adam',
13 loss='sparse_categorical_crossentropy',
14 metrics=['accuracy'])
15

16 # Dummy data for demonstration

17 x_train = tf.random.normal((1000, 784)) # 1000 samples of 784 features
18 y_train = tf.random.uniform((1000,), maxval=10, dtype=tf.int32) # 1000 labels
19

20 # Train the model

21 model.fit(x_train, y_train, epochs=5)

In this example, we define a simple fully connected neural network using two hidden layers with ReLU
activation and an output layer with softmax activation for classification. The model is compiled with
the Adam optimizer and trained on randomly generated data.

9.2.2 Overview of PyTorch

PyTorch is an open-source deep learning framework developed by Facebook’s AI Research lab. It has
gained significant popularity in the research community due to its flexibility and dynamic computa-
tional graph, making it easier to debug and modify models on the go. PyTorch also integrates well
with Python’s scientific libraries, such as NumPy and SciPy.
Unlike TensorFlow, which relies on static computational graphs, PyTorch’s dynamic graph (also
known as define-by-run) allows computations to be defined as they happen, providing greater flexibility,
especially for research and experimentation.
 120 CHAPTER 9. GETTING STARTED WITH DEEP LEARNING

Basic Neural Network in PyTorch: The following example demonstrates how to create a simple
feedforward neural network using PyTorch:

1 import torch
2 import torch.nn as nn
3 import torch.optim as optim
4

5 # Define a simple neural network model

6 class SimpleNN(nn.Module):
7 def __init__(self):
8 super(SimpleNN, self).__init__()
9 self.fc1 = nn.Linear(784, 128)
10 self.fc2 = nn.Linear(128, 64)
11 self.fc3 = nn.Linear(64, 10)
12

13 def forward(self, x):

14 x = torch.relu(self.fc1(x))
15 x = torch.relu(self.fc2(x))
16 x = torch.softmax(self.fc3(x), dim=1)
17 return x
18

19 # Initialize the model, loss function, and optimizer

20 model = SimpleNN()
21 criterion = nn.CrossEntropyLoss()
22 optimizer = optim.Adam(model.parameters(), lr=0.001)
23

24 # Dummy data for demonstration

25 x_train = torch.randn(1000, 784) # 1000 samples of 784 features
26 y_train = torch.randint(0, 10, (1000,)) # 1000 labels
27

28 # Training loop
29 for epoch in range(5):
30 optimizer.zero_grad()
31 outputs = model(x_train)
32 loss = criterion(outputs, y_train)
33 loss.backward()
34 optimizer.step()
35

36 if epoch % 1 == 0:
37 print(f'Epoch {epoch+1}, Loss: {loss.item()}')

In this PyTorch example, we define a simple neural network with two hidden layers. The model is
trained using stochastic gradient descent with the Adam optimizer, and the loss is computed using
cross-entropy loss on randomly generated data.

9.3 Building Your First Deep Learning Model

In this section, we will guide you through building a simple deep-learning model, covering dataset
preparation, defining the model architecture, and training it.
 9.3. BUILDING YOUR FIRST DEEP LEARNING MODEL 121

9.3.1 Dataset Preparation

Deep learning models require large amounts of data to train effectively. Some of the most common
datasets used in the field are:

• MNIST: A dataset of handwritten digits (28x28 grayscale images) used for classification tasks [57].

• CIFAR-10: A dataset containing 60,000 color images in 10 classes, with each image sized 32x32
pixels [53].

In TensorFlow, datasets like MNIST can be loaded directly using the tensorflow.keras.datasets
module:

1 import tensorflow as tf
2

3 # Load the MNIST dataset

4 (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
5

6 # Normalize the pixel values between 0 and 1

7 x_train, x_test = x_train / 255.0, x_test / 255.0

Similarly, in PyTorch, datasets like CIFAR-10 can be loaded using torchvision.datasets:

1 import torchvision
2 import torchvision.transforms as transforms
3

4 # Transform to normalize the data

5 transform = transforms.Compose([
6 transforms.ToTensor(),
7 transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
8 ])
9

10 # Load the CIFAR-10 dataset

11 trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
12 download=True, transform=transform)
13 trainloader = torch.utils.data.DataLoader(trainset, batch_size=32,
14 shuffle=True)

These libraries provide convenient access to widely used datasets, allowing you to focus on model
building.

9.3.2 Defining the Model

The next step is to define a simple feedforward neural network, also known as a fully connected net-
work. In both TensorFlow and PyTorch, this involves stacking layers, specifying activation functions,
and configuring the output units based on the task.
TensorFlow: Defining a Feedforward Neural Network

1 import tensorflow as tf
2 from tensorflow.keras import layers
3

4 # Define the model

 122 CHAPTER 9. GETTING STARTED WITH DEEP LEARNING

5 model = tf.keras.Sequential([
6 layers.Flatten(input_shape=(28, 28)), # Flatten the input (for MNIST)
7 layers.Dense(128, activation='relu'), # Hidden layer
8 layers.Dense(10, activation='softmax') # Output layer for 10 classes
9 ])

Here, the input is flattened to a 1D vector, followed by a dense hidden layer with ReLU activation and
an output layer with 10 units (for the 10 classes in MNIST), using softmax for classification.
PyTorch: Defining a Feedforward Neural Network

1 import torch.nn as nn
2 import torch.nn.functional as F
3

4 # Define the model

5 class SimpleNN(nn.Module):
6 def __init__(self):
7 super(SimpleNN, self).__init__()
8 self.fc1 = nn.Linear(28 * 28, 128) # Input layer (for MNIST)
9 self.fc2 = nn.Linear(128, 10) # Output layer for 10 classes
10

11 def forward(self, x):

12 x = x.view(-1, 28*28) # Flatten the input
13 x = F.relu(self.fc1(x)) # Hidden layer with ReLU
14 x = F.log_softmax(self.fc2(x), dim=1) # Output layer with softmax
15 return x
16

17 model = SimpleNN()

In PyTorch, the input is also flattened, followed by a hidden layer with ReLU activation, and the output
layer uses log_softmax for classification.

9.3.3 Compiling and Training the Model

Once the model is defined, the next step is to compile it with an optimizer and loss function, and then
train it.
TensorFlow: Compiling and Training the Model

1 # Compile the model

2 model.compile(optimizer='adam',
3 loss='sparse_categorical_crossentropy',
4 metrics=['accuracy'])
5

6 # Train the model

7 model.fit(x_train, y_train, epochs=5, batch_size=32)

In TensorFlow, we compile the model with the Adam optimizer and a cross-entropy loss function, which
is suitable for classification tasks. The model is then trained using the fit method.
PyTorch: Training the Model In PyTorch, the training process is more explicit, as we need to define
the training loop manually:

1 import torch.optim as optim

 9.4. EVALUATING AND FINE-TUNING YOUR MODEL 123

3 # Define the optimizer and loss function

4 optimizer = optim.Adam(model.parameters(), lr=0.001)
5 criterion = nn.CrossEntropyLoss()
6

7 # Training loop
8 for epoch in range(5):
9 for inputs, labels in trainloader:
10 optimizer.zero_grad() # Zero the gradients
11 outputs = model(inputs) # Forward pass
12 loss = criterion(outputs, labels) # Compute loss
13 loss.backward() # Backward pass
14 optimizer.step() # Update weights
15

16 print(f'Epoch {epoch+1}, Loss: {loss.item()}')

In PyTorch, we define the optimizer and loss function manually, then write a loop to feed data through
the model, compute the loss, backpropagate the gradients, and update the model weights.
Both frameworks allow us to effectively train deep learning models, with TensorFlow offering a
more high-level API and PyTorch providing more granular control.

9.4 Evaluating and Fine-Tuning Your Model

After training a deep learning model, it’s essential to evaluate its performance and fine-tune it to im-
prove accuracy and generalization. In this section, we will cover how to evaluate the model, save and
load models, and perform basic hyperparameter tuning.

9.4.1 Evaluating Model Performance

Evaluating a model involves assessing its performance on unseen test data. A key goal of this process
is to determine whether the model can generalize well to new data. Several metrics are commonly used
to evaluate model performance, including accuracy, loss, and confusion matrices.
TensorFlow: Evaluating on Test Data In TensorFlow, evaluating a model on test data is straightfor-
ward:

1 # Evaluate the model on the test set

2 test_loss, test_acc = model.evaluate(x_test, y_test)
3 print(f'Test accuracy: {test_acc}')

The evaluate function returns the loss and accuracy on the test dataset.
PyTorch: Evaluating on Test Data In PyTorch, we evaluate the model using the following loop:

1 correct = 0
2 total = 0
3 model.eval() # Set the model to evaluation mode
4

5 with torch.no_grad(): # Disable gradient computation

6 for data in testloader:
7 inputs, labels = data
 124 CHAPTER 9. GETTING STARTED WITH DEEP LEARNING

8 outputs = model(inputs)
9 _, predicted = torch.max(outputs.data, 1)
10 total += labels.size(0)
11 correct += (predicted == labels).sum().item()
12

13 print(f'Accuracy on test set: {100 * correct / total}%')

In this code, we loop over the test dataset, compute the predicted classes, and compare them to the
true labels to compute accuracy.
Confusion Matrices: For classification tasks, confusion matrices provide more detailed insight
into model performance by showing how many samples were correctly or incorrectly classified for
each class. A confusion matrix can be generated in Python using the sklearn.metrics library:
1 from sklearn.metrics import confusion_matrix
2 import seaborn as sns
3 import matplotlib.pyplot as plt
4

5 # True labels and predicted labels

6 y_true = [2, 0, 2, 2, 0, 1]
7 y_pred = [0, 0, 2, 2, 0, 2]
8

9 # Create confusion matrix

10 conf_matrix = confusion_matrix(y_true, y_pred)
11

12 # Plot the confusion matrix

13 sns.heatmap(conf_matrix, annot=True, cmap='Blues')
14 plt.show()

9.4.2 Saving and Loading Models

After training a model, it’s essential to save it for future use. This allows you to resume training later
or use the model for inference without retraining from scratch.
TensorFlow: Saving and Loading Models TensorFlow provides simple methods for saving and
loading models:
1 # Save the model
2 model.save('my_model.h5')
3

4 # Load the model

5 loaded_model = tf.keras.models.load_model('my_model.h5')
6

7 # Use the loaded model to make predictions

8 predictions = loaded_model.predict(x_test)

In TensorFlow, models are saved in the HDF5 format by default and can be reloaded easily for further
use.
PyTorch: Saving and Loading Models In PyTorch, saving and loading models are slightly different,
using torch.save and torch.load:
1 # Save the model
 9.4. EVALUATING AND FINE-TUNING YOUR MODEL 125

2 torch.save(model.state_dict(), 'model.pth')
3

4 # Load the model

5 model = SimpleNN()
6 model.load_state_dict(torch.load('model.pth'))
7 model.eval() # Set the model to evaluation mode
8

9 # Use the loaded model for inference

10 outputs = model(inputs)

In PyTorch, we save the model’s state dictionary, which contains all the model parameters, and reload
it when needed.

9.4.3 Basic Hyperparameter Tuning

Hyperparameters are values that define how a model is trained. Some of the most common hyperpa-
rameters include:

• Learning rate: Determines how quickly the model’s weights are updated during training.

• Batch size: Defines the number of samples processed before updating the model’s weights.

• Number of epochs: Refers to how many times the model sees the entire training dataset.

Tuning these hyperparameters can significantly affect model performance.

Learning Rate: A learning rate that is too high may cause the model to converge too quickly to a
suboptimal solution, while a learning rate that is too low may result in slow convergence. In Tensor-
Flow, the learning rate can be adjusted when defining the optimizer:
1 # Adjust the learning rate in the Adam optimizer
2 model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001),
3 loss='sparse_categorical_crossentropy',
4 metrics=['accuracy'])

In PyTorch, you can modify the learning rate when setting up the optimizer:
1 optimizer = optim.Adam(model.parameters(), lr=0.0001)

Batch Size: Increasing the batch size can lead to faster training, but larger batches require more
memory. A smaller batch size can result in more frequent updates and may help improve generaliza-
tion but could increase training time.
In TensorFlow:
1 model.fit(x_train, y_train, epochs=5, batch_size=64) # Batch size is 64

In PyTorch, the batch size is defined in the DataLoader:

1 trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

Number of Epochs: The number of epochs determines how many times the model will iterate over
the entire training dataset. Increasing the number of epochs may improve model accuracy, but too
many epochs can lead to overfitting.
You can experiment with these hyperparameters to find the best combination for your specific
dataset and model.
 126 CHAPTER 9. GETTING STARTED WITH DEEP LEARNING

9.5 Implementing More Complex Models

In this section, we will explore more advanced neural network architectures, such as Convolutional
Neural Networks (CNNs) for image processing and Recurrent Neural Networks (RNNs) for sequential
data tasks.

9.5.1 Convolutional Neural Networks (CNNs)

Convolutional Neural Networks (CNNs) are specialized neural networks designed for processing grid-
like data such as images. CNNs are widely used for image classification, object detection, and other
image-related tasks. They are designed to automatically capture spatial hierarchies in data through
the use of convolutional layers, pooling layers, and fully connected layers.
CNN Architecture: A typical CNN consists of:

• Convolutional Layers: Apply convolution operations to extract features from the input data.

• Pooling Layers: Reduce the dimensionality of feature maps, retaining important features.

• Fully Connected Layers: Perform classification based on the extracted features.

TensorFlow: Implementing a Simple CNN Here’s how you can build a simple CNN for image clas-
sification using TensorFlow:

1 import tensorflow as tf
2 from tensorflow.keras import layers, models
3

4 # Define the CNN model

5 model = models.Sequential([
6 layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
7 layers.MaxPooling2D((2, 2)),
8 layers.Conv2D(64, (3, 3), activation='relu'),
9 layers.MaxPooling2D((2, 2)),
10 layers.Conv2D(64, (3, 3), activation='relu'),
11 layers.Flatten(),
12 layers.Dense(64, activation='relu'),
13 layers.Dense(10, activation='softmax') # 10 output classes
14 ])
15

16 # Compile the model

17 model.compile(optimizer='adam',
18 loss='sparse_categorical_crossentropy',
19 metrics=['accuracy'])
20

21 # Print the model summary

22 model.summary()

In this example, the CNN consists of three convolutional layers with ReLU activation and two pool-
ing layers to down-sample the feature maps. The network ends with fully connected layers for classi-
fication into 10 classes.
PyTorch: Implementing a Simple CNN Here’s how to build the same CNN using PyTorch:
 9.5. IMPLEMENTING MORE COMPLEX MODELS 127

1 import torch
2 import torch.nn as nn
3 import torch.nn.functional as F
4

5 # Define the CNN model

6 class SimpleCNN(nn.Module):
7 def __init__(self):
8 super(SimpleCNN, self).__init__()
9 self.conv1 = nn.Conv2d(3, 32, 3, padding=1) # Input: 3 channels (RGB), Output: 32 filters
10 self.pool = nn.MaxPool2d(2, 2) # Max pooling with a 2x2 window
11 self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
12 self.conv3 = nn.Conv2d(64, 64, 3, padding=1)
13 self.fc1 = nn.Linear(64 * 8 * 8, 64) # Fully connected layer
14 self.fc2 = nn.Linear(64, 10) # Output layer for 10 classes
15

16 def forward(self, x):

17 x = self.pool(F.relu(self.conv1(x)))
18 x = self.pool(F.relu(self.conv2(x)))
19 x = self.pool(F.relu(self.conv3(x)))
20 x = x.view(-1, 64 * 8 * 8) # Flatten the tensor
21 x = F.relu(self.fc1(x))
22 x = F.log_softmax(self.fc2(x), dim=1)
23 return x
24

25 # Create the model instance

26 model = SimpleCNN()

In this PyTorch implementation, we define a CNN with three convolutional layers followed by max
pooling and then flatten the feature maps to feed into two fully connected layers for classification.

9.5.2 Recurrent Neural Networks (RNNs)

Recurrent Neural Networks (RNNs) [88] are designed to handle sequential data by maintaining a hidden
state that can capture information from previous time steps. They are commonly used for tasks such
as time series forecasting, language modeling, and text generation. More advanced versions of RNNs,
such as Long Short-Term Memory (LSTM) and Gated Recurrent Units (GRU), are capable of capturing
long-term dependencies in sequences.
RNN Architecture: A typical RNN consists of:

• Input Layers: Accept sequential input data (e.g., time series, text sequences).

• Recurrent Layers: Process sequential data by maintaining a hidden state.

• Output Layers: Produce predictions based on the processed sequences.

TensorFlow: Implementing an LSTM for Text Classification Here’s how you can implement an
LSTM model for text classification using TensorFlow:

1 import tensorflow as tf
2 from tensorflow.keras import layers
 128 CHAPTER 9. GETTING STARTED WITH DEEP LEARNING

4 # Define an LSTM model for text classification

5 model = tf.keras.Sequential([
6 layers.Embedding(input_dim=10000, output_dim=64), # Embedding layer for word vectors
7 layers.LSTM(128), # LSTM layer with 128 units
8 layers.Dense(10, activation='softmax') # Output layer for classification
9 ])
10

11 # Compile the model

12 model.compile(optimizer='adam',
13 loss='sparse_categorical_crossentropy',
14 metrics=['accuracy'])
15

16 # Print the model summary

17 model.summary()

In this example, we use an embedding layer to convert words into vectors, followed by an LSTM
layer to process the sequential data, and an output layer with 10 units for classification.
PyTorch: Implementing an LSTM for Text Classification Here’s how you can implement an LSTM
model using PyTorch:

1 import torch
2 import torch.nn as nn
3

4 # Define the LSTM model for text classification

5 class LSTMModel(nn.Module):
6 def __init__(self):
7 super(LSTMModel, self).__init__()
8 self.embedding = nn.Embedding(10000, 64) # Embedding layer
9 self.lstm = nn.LSTM(64, 128, batch_first=True) # LSTM layer
10 self.fc = nn.Linear(128, 10) # Fully connected output layer
11

12 def forward(self, x):

13 x = self.embedding(x) # Convert words to vectors
14 lstm_out, _ = self.lstm(x) # Pass through LSTM
15 x = lstm_out[:, -1, :] # Get the output of the last time step
16 x = self.fc(x) # Pass through the fully connected layer
17 return x
18

19 # Create the model instance

20 model = LSTMModel()

In this PyTorch implementation, we define an LSTM model with an embedding layer, an LSTM layer
to process the sequences, and a fully connected layer for the classification task.

9.6 Using Pre-trained Models and Transfer Learning

Transfer learning is a powerful technique in deep learning that allows you to leverage pre-trained mod-
els on large datasets to solve new tasks with limited data. Instead of training a model from scratch,
 9.6. USING PRE-TRAINED MODELS AND TRANSFER LEARNING 129

you can use an existing model trained on a large dataset (e.g., ImageNet) and fine-tune it for your
specific task. This approach is particularly useful when working with small datasets or when training
deep models that would otherwise take a long time to converge.

9.6.1 Introduction to Transfer Learning

Transfer Learning refers to the process of taking a pre-trained model and reusing it for a new, but
related, task. In deep learning workflows, this approach is beneficial because:

• It reduces the amount of training time and data required.

• Pre-trained models have already learned useful features from a large dataset, which can be re-
purposed for new tasks.

• It improves performance on tasks where you don’t have enough labeled data.

Transfer learning typically involves the following steps:

• Load a pre-trained model that has been trained on a large dataset.

• Replace the final layer(s) to fit your specific task (e.g., change the number of output classes).

• Fine-tune the model on your custom dataset, either by training only the new layers or by fine-
tuning the entire model.

9.6.2 Using Pre-trained Models in TensorFlow and PyTorch

Both TensorFlow and PyTorch provide pre-trained models [20] through their respective libraries, such
as tensorflow.keras.applications and torchvision.models.
TensorFlow: Using a Pre-trained Model (VGG16) In TensorFlow, you can load pre-trained models
from tensorflow.keras.applications and fine-tune them on your custom dataset. Here’s how to use
the VGG16 [92] model pre-trained on ImageNet:

1 import tensorflow as tf
2 from tensorflow.keras.applications import VGG16
3 from tensorflow.keras import layers, models
4

5 # Load the pre-trained VGG16 model, exclude the top layer (for custom output)
6 base_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
7

8 # Freeze the base model layers

9 base_model.trainable = False
10

11 # Create a new model with custom top layers

12 model = models.Sequential([
13 base_model,
14 layers.Flatten(),
15 layers.Dense(128, activation='relu'),
16 layers.Dense(10, activation='softmax') # 10 output classes for classification
17 ])
18
 130 CHAPTER 9. GETTING STARTED WITH DEEP LEARNING

19 # Compile the model

20 model.compile(optimizer='adam',
21 loss='sparse_categorical_crossentropy',
22 metrics=['accuracy'])
23

24 # Fine-tune the model on your custom dataset

25 # x_train and y_train should be your custom data
26 model.fit(x_train, y_train, epochs=5, batch_size=32)

In this example, we load the VGG16 model, freeze its pre-trained layers, and add custom layers to
adapt it for a new classification task. You can also unfreeze the layers and fine-tune the entire model
if needed.
PyTorch: Using a Pre-trained Model (ResNet) Similarly, in PyTorch, you can load pre-trained mod-
els from torchvision.models and fine-tune them. Below is an example using the ResNet18 model:

1 import torch
2 import torch.nn as nn
3 import torchvision.models as models
4

5 # Load the pre-trained ResNet18 model

6 resnet = models.resnet18(pretrained=True)
7

8 # Freeze all layers of the base model

9 for param in resnet.parameters():
10 param.requires_grad = False
11

12 # Replace the final fully connected layer with a new one for your task
13 num_ftrs = resnet.fc.in_features
14 resnet.fc = nn.Linear(num_ftrs, 10) # 10 output classes
15

16 # Define the loss function and optimizer

17 criterion = nn.CrossEntropyLoss()
18 optimizer = torch.optim.Adam(resnet.fc.parameters(), lr=0.001)
19

20 # Train the model on your custom dataset

21 for epoch in range(5):
22 for inputs, labels in trainloader:
23 optimizer.zero_grad()
24 outputs = resnet(inputs)
25 loss = criterion(outputs, labels)
26 loss.backward()
27 optimizer.step()
28

29 print(f'Epoch {epoch+1}, Loss: {loss.item()}')

In this example, we load the ResNet18 model, freeze the pre-trained layers, and replace the final
fully connected layer with one suited for our custom task (e.g., 10 output classes). We then fine-tune
the model on our dataset.
 9.6. USING PRE-TRAINED MODELS AND TRANSFER LEARNING 131

9.6.3 Fine-tuning a Pre-trained Model on a Custom Dataset

Fine-tuning a pre-trained model involves two primary strategies:

• Feature extraction: Freeze the pre-trained model’s layers and only train the new layers you’ve
added. This is useful when you don’t have much data or want to preserve the learned features
from the base model.

• Fine-tuning: Unfreeze some or all of the layers of the pre-trained model and train them alongside
the new layers. This allows the entire model to adapt to the new dataset.

Here’s how to fine-tune a model by unfreezing some layers (e.g., the top few convolutional layers)
in TensorFlow:

1 # Unfreeze the top layers of the base model

2 for layer in base_model.layers[-4:]:
3 layer.trainable = True
4

5 # Recompile the model with a lower learning rate for fine-tuning

6 model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5),
7 loss='sparse_categorical_crossentropy',
8 metrics=['accuracy'])
9

10 # Continue training (fine-tuning) the model

11 model.fit(x_train, y_train, epochs=10, batch_size=32)

In PyTorch, you can similarly unfreeze certain layers and adjust the optimizer to fine-tune the entire
model.

1 # Unfreeze some layers of ResNet for fine-tuning

2 for name, param in resnet.named_parameters():
3 if "layer4" in name: # Unfreeze the last residual block (layer4)
4 param.requires_grad = True
5

6 # Re-define the optimizer to include the unfrozen layers

7 optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, resnet.parameters()), lr=1e-5)
8

9 # Fine-tune the model

10 for epoch in range(10):
11 for inputs, labels in trainloader:
12 optimizer.zero_grad()
13 outputs = resnet(inputs)
14 loss = criterion(outputs, labels)
15 loss.backward()
16 optimizer.step()
17

18 print(f'Epoch {epoch+1}, Loss: {loss.item()}')

Fine-tuning allows the model to better adapt to your custom dataset while still benefiting from the
features learned in the pre-training phase.
 132 CHAPTER 9. GETTING STARTED WITH DEEP LEARNING

9.7 Practical Considerations

When moving from research to production, there are several important considerations, including how
to deploy models effectively and how to optimize them for speed and performance. This section will
cover common deployment techniques and methods to enhance model efficiency.

9.7.1 Model Deployment

Deploying a deep learning model involves making the model accessible for inference in a production
environment, whether it’s on a server, in the cloud, or on edge devices.
Deployment Techniques: There are various tools and techniques for deploying machine learning
models. Two popular methods are:
TensorFlow Serving: TensorFlow Serving is a flexible, high-performance system for serving ma-
chine learning models in production environments. It provides an easy way to serve TensorFlow mod-
els and is compatible with TensorFlow Extended (TFX) pipelines.

# Install TensorFlow Serving

sudo apt-get install tensorflow-model-server

# Serve a model
tensorflow_model_server --rest_api_port=8501 --model_name=my_model --model_base_path=/path/to/
model/

TorchScript: For PyTorch models, TorchScript is a way to serialize and optimize deployment mod-
els. It converts PyTorch models into a format that can be run in a high-performance environment,
independent of Python.

1 import torch
2

3 # Convert a PyTorch model to TorchScript

4 scripted_model = torch.jit.script(model)
5

6 # Save the scripted model

7 scripted_model.save("model.pt")
8

9 # Load and run the model in a production environment

10 loaded_model = torch.jit.load("model.pt")
11 loaded_model(input_tensor)

Cloud Services for Model Deployment: Cloud platforms like AWS, Google Cloud, and Azure provide
robust services for deploying and scaling machine learning models.

• AWS Sagemaker: AWS Sagemaker [5] allows you to train and deploy machine learning models
at scale. It simplifies the process of building, training, and deploying models in the cloud.

• Google Cloud AI Platform: Google Cloud offers AI Platform [34], which integrates with Tensor-
Flow and other ML frameworks to deploy and manage models at scale.

• Azure Machine Learning: Azure [63] provides services for training, deploying, and managing
machine learning models, including support for PyTorch, TensorFlow, and Scikit-learn.
 9.7. PRACTICAL CONSIDERATIONS 133

9.7.2 Optimizing for Speed and Performance

Optimizing deep learning models is crucial when deploying them in production environments where
speed and resource efficiency are important. Several techniques can be used to reduce model size
and improve inference speed without significantly sacrificing accuracy.
Quantization: Quantization reduces the precision of the numbers used to represent model weights
and activations, typically from 32-bit floating-point to 8-bit integers. This can significantly reduce
the model size and improve inference speed, especially on resource-constrained devices like mobile
phones or edge devices.
TensorFlow Quantization: TensorFlow supports post-training quantization, where you can quan-
tize a trained model:
1 import tensorflow as tf
2

3 # Load the trained model

4 model = tf.keras.models.load_model('my_model.h5')
5

6 # Convert the model to a TensorFlow Lite model with quantization

7 converter = tf.lite.TFLiteConverter.from_keras_model(model)
8 converter.optimizations = [tf.lite.Optimize.DEFAULT]
9 quantized_model = converter.convert()
10

11 # Save the quantized model

12 with open('quantized_model.tflite', 'wb') as f:
13 f.write(quantized_model)

PyTorch Quantization: In PyTorch, you can apply dynamic quantization, which quantizes the model
weights to 8-bit integers:
1 import torch.quantization
2

3 # Apply dynamic quantization

4 quantized_model = torch.quantization.quantize_dynamic(
5 model, {torch.nn.Linear}, dtype=torch.qint8
6 )
7

8 # Save the quantized model

9 torch.jit.save(torch.jit.script(quantized_model), "quantized_model.pt")

Model Pruning: Model pruning involves removing weights or entire neurons from the network that
have little contribution to the model’s output. This reduces the number of parameters, making the
model smaller and faster without significantly impacting accuracy.
TensorFlow Pruning: TensorFlow offers pruning capabilities through the TensorFlow Model Opti-
mization Toolkit:
1 import tensorflow_model_optimization as tfmot
2

3 # Apply pruning to the model

4 prune_low_magnitude = tfmot.sparsity.keras.prune_low_magnitude
5 pruned_model = prune_low_magnitude(model)
6
 134 CHAPTER 9. GETTING STARTED WITH DEEP LEARNING

7 # Compile and train the pruned model

8 pruned_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
9 pruned_model.fit(x_train, y_train, epochs=5)

PyTorch Pruning: In PyTorch, you can prune certain layers or entire networks:

1 import torch.nn.utils.prune as prune

2

3 # Prune 50% of the connections in the first linear layer

4 prune.l1_unstructured(model.fc1, name='weight', amount=0.5)
5

6 # Remove the pruning reparametrization to make it permanent

7 prune.remove(model.fc1, 'weight')

Optimizing models through techniques like quantization and pruning can greatly enhance perfor-
mance, particularly when deploying models to edge devices or cloud environments with limited com-
putational resources.
Chapter 10

Data Visualization

Data visualization plays a critical role in data analysis and scientific research. By transforming com-
plex data into intuitive graphs and charts, data visualization helps us easily identify trends, patterns,
and anomalies, thereby enhancing the accuracy of decision-making. It is not only an effective way to
present the results of data but also a vital tool for data exploration. Data visualization allows complex
datasets to be displayed concisely and understandably, enabling audiences to quickly grasp the core
information. Whether used in business analysis, academic research, or everyday decision support,
data visualization is an indispensable tool. Through data visualization, we can more clearly under-
stand the story behind the data and effectively share these insights with others.

10.1 The Importance of Data Visualization

In a particular grade, we have the height data of 200 students listed below. When looking at these
numbers arranged in a table, it’s challenging to discern any meaningful patterns or trends due to the
sheer volume and scattered distribution of the data. The overall distribution, central tendencies, and
potential outliers are all hidden within this dense set of numbers, making it difficult to interpret by
eye. In such cases, using visualization tools like histograms can help us better understand the data
distribution, allowing us to see the concentration, range, and shape of the data more clearly, thus
uncovering any underlying patterns.

174 168 176 185 167 167 185 177 165 175 165 165 172 150 152 164 159 173 160 155
184 167 170 155 164 171 158 173 163 167 163 188 169 159 178 157 172 150 156 171
177 171 168 166 155 162 165 180 173 152 173 166 163 176 180 179 161 166 173 179
165 168 158 158 178 183 169 180 173 163 173 185 169 185 143 178 170 167 170 150
167 173 184 164 161 164 179 173 164 175 170 179 162 166 166 155 172 172 170 167
155 165 166 161 168 174 188 171 172 169 150 169 170 194 168 173 169 158 181 177
177 160 184 155 175 191 160 164 170 164 154 170 159 174 160 185 162 166 178 157
172 183 153 171 172 177 157 156 175 172 172 173 163 172 172 162 188 174 158 176
160 177 181 161 179 174 178 188 167 162 161 161 169 173 172 178 170 184 167 197
176 161 159 174 167 177 174 169 161 154 165 178 172 157 171 173 161 171 170 158

Table 10.1: Heights of 200 Students (in cm)

135
 136 CHAPTER 10. DATA VISUALIZATION

Distribution of Heights Among 200 Students

30

25
Number of Students

20

15

10

0
150 160 170 180 190
Height (cm)

Figure 10.1: Histogram of Student Heights

This chart shows the distribution of heights among 200 students. As illustrated, the majority of
heights are concentrated between 160 cm and 180 cm, with a clear peak around 170 cm, forming an
evident normal distribution. Visualization like this allows us to easily observe the distribution, identify
the central tendencies, and spot any anomalies. If we were to rely solely on raw data, such patterns
would be much harder to detect. Thus, data visualization is crucial for understanding and analyzing
large datasets; it simplifies complex information and helps us make quick, accurate decisions.
The code presented in this section is designed to generate and visualize a distribution of student
heights using Python. It begins by importing the necessary libraries, setting a random seed for repro-
ducibility, and generating a dataset of heights following a normal distribution. The heights are then
displayed in a formatted manner with 20 numbers per row for better readability. Finally, the code
creates a histogram with improved aesthetics, including custom colors, labels, and grid settings, to
visually represent the distribution of heights among 200 students.

1 import numpy as np
2 import matplotlib.pyplot as plt
3

5 # Set a random seed for reproducibility

6 np.random.seed(42)
7

8 # Generate random heights following a normal distribution

9 heights = np.random.normal(loc=170, scale=10, size=200)
10

11 # Print the data in a format of 20 numbers per row

 10.2. COMMONLY USED VISUALIZATION CHARTS 137

12 for i in range(0, len(heights), 20):

13 for j in range(20):
14 print(int(heights[i + j]), end=" ")
15 print() # New line after each row
16

17 # Plot a histogram with improved aesthetics

18 plt.figure(figsize=(12, 8)) # Increase the figure size
19 plt.hist(heights, bins=15, color='#4CAF50', edgecolor='black', alpha=0.75) # Use a pleasing green
color
20

21 # Add title and labels with improved font settings

22 plt.title('Distribution of Heights Among 200 Students', fontsize=18, fontweight='bold', color='
#333333')
23 plt.xlabel('Height (cm)', fontsize=15, fontweight='bold', color='#333333')
24 plt.ylabel('Number of Students', fontsize=15, fontweight='bold', color='#333333')
25

26 # Customize grid and ticks for better readability

27 plt.grid(True, linestyle='--', alpha=0.5, color='gray')
28 plt.xticks(fontsize=13, fontweight='bold', color='#555555')
29 plt.yticks(fontsize=13, fontweight='bold', color='#555555')
30

31 # Display the histogram

32 plt.show()

10.2 Commonly used Visualization Charts

10.2.1 Line Chart

A Line Chart is a fundamental type of statistical chart used to display data points connected by straight
line segments, showing trends over a continuous variable, often time. It is commonly used in data
visualization to observe the behavior of variables over time or another continuous scale.
In this section, we will draw a simple line chart representing a quadratic function. The function is
of the form y = ax2 + bx + c. For this example, we will set a = 1, b = 0, and c = 0, resulting in y = x2 .
We will plot the values of this function for x ranging from -10 to 10.

1 import matplotlib.pyplot as plt

2 import numpy as np
3

4 # Define the range for x

5 x = np.linspace(-10, 10, 100)
6 # Define the quadratic function y = x^2
7 y = x**2
8

9 # Plotting the line chart

10 plt.figure(figsize=(10, 6))
11 plt.plot(x, y, marker='o')
12 plt.title('Line Chart of Quadratic Function $y = x^2$')
13 plt.xlabel('x')
 138 CHAPTER 10. DATA VISUALIZATION

14 plt.ylabel('y')
15 plt.grid(True)
16 plt.show()

In the above code, the x array represents values ranging from -10 to 10, and the corresponding y
array represents the values calculated using the quadratic function y = x2 . We use the plt.plot()
function to draw a line chart, with markers (marker=’o’) highlighting each calculated point.
The chart’s title is "Line Chart of Quadratic Function y = x2 ", with the x-axis labeled "x" and the
y-axis labeled "y". The grid is enabled using plt.grid(True) to help better visualize the position of
each data point.
Below is the line chart illustrating the quadratic function y = x2 over the range -10 to 10:

[H]

Line Chart of Quadratic Function y = x2

100

80

60
y

40

20

0
10.0 7.5 5.0 2.5 0.0 2.5 5.0 7.5 10.0
x

This chart shows the typical parabolic shape of a quadratic function, demonstrating the squared
relationship between the independent variable x and the dependent variable y.

10.2.2 Pie Chart

A Pie Chart is a circular statistical graphic divided into slices to represent numerical proportions. The
size of each slice corresponds to its contribution to the total sum. Pie charts are commonly used
in statistics, business, and media to display the relative proportions of different categories within a
dataset.
In this section, we will use a pie chart to illustrate the probability distribution of the sum of points
obtained when rolling three six-sided dice. Below is the Python code to generate a pie chart that
represents the probabilities of different sums when rolling three dice:
1 import matplotlib.pyplot as plt
2 from collections import Counter
3 import numpy as np
 10.2. COMMONLY USED VISUALIZATION CHARTS 139

5 # Calculate the probabilities

6 sums = [sum(roll) for roll in np.ndindex(6, 6, 6)]
7 sum_counts = Counter(sums)
8 total_rolls = 6**3
9 probabilities = {sum_value: count / total_rolls * 100 for sum_value, count in sum_counts.items()}
10

11 # Data for the pie chart

12 labels = probabilities.keys()
13 sizes = probabilities.values()
14

15 # Plotting the pie chart with a colormap

16 plt.figure(figsize=(10,10))
17 cmap = plt.get_cmap('jet')
18 colors = cmap(np.linspace(0, 1, len(labels)))
19 plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=140)
20 plt.title('Probability Distribution of Sums for Three Dice Rolls')
21 plt.show()

This code simulates the probability distribution of sums when rolling three dice and visualizes it
using a pie chart. Each slice represents the probability of a specific sum occurring.
 140 CHAPTER 10. DATA VISUALIZATION

Probability Distribution of Sums for Three Dice Rolls

11
12 10
13
14
15
0
1
6.9%
2 4.6% 9.7%
2.8% 9
1.4%
0.5%
0.5%
1.4%
3 2.8% 11.6%
4.6%

6.9%
4
12.5%

9.7% 8

12.5%
11.6%
5

7
6

Figure 10.2: Probability Distribution of Sums for Three Dice Rolls

10.2.3 Bar Chart

A Bar Chart is a graphical representation of data using rectangular bars. The length of each bar is
proportional to the value it represents. Bar charts are commonly used to compare different categories
or to track changes over time.
In this section, we will use a bar chart to illustrate the probability distribution of the sum of points
obtained when rolling three six-sided dice.

1 import matplotlib.pyplot as plt

2 from collections import Counter
3 import numpy as np
4

5 # Calculate the probabilities

6 sums = [sum(roll) for roll in np.ndindex(6, 6, 6)]
 10.2. COMMONLY USED VISUALIZATION CHARTS 141

7 sum_counts = Counter(sums)
8 total_rolls = 6**3
9 probabilities = {sum_value: count / total_rolls * 100 for sum_value, count in sum_counts.items()}
10

11 # Data for the bar chart

12 labels = list(probabilities.keys())
13 sizes = list(probabilities.values())
14

15 # Plotting the bar chart with a colormap

16 plt.figure(figsize=(10,6))
17 cmap = plt.get_cmap('viridis')
18 colors = cmap(np.linspace(0, 1, len(labels)))
19 plt.bar(labels, sizes, color=colors)
20 plt.xlabel('Sum of Dice Rolls')
21 plt.ylabel('Probability (%)')
22 plt.title('Probability Distribution of Sums for Three Dice Rolls')
23 plt.show()

This code calculates the probability distribution for sums when rolling three dice and visualizes
it using a bar chart with colors derived from the “viridis” colormap. You can see that the number of
points from the three dice combinations conforms to the normal distribution. The use of visualization
presents this mathematical law.

Probability Distribution of Sums for Three Dice Rolls

12

10

8
Probability (%)

0
0 2 4 6 8 10 12 14 16
Sum of Dice Rolls

Figure 10.3: Probability Distribution of Sums for Three Dice Rolls

10.2.4 Histogram
A histogram is a commonly used statistical chart to display the distribution of data. It divides the data
into continuous intervals (called "bins") and counts the number of data points within each interval
 142 CHAPTER 10. DATA VISUALIZATION

(frequency), which reflects the frequency distribution of the data. Unlike a bar chart, the horizontal
axis of a histogram represents continuous values, making it suitable for numerical data.

In this example, we simulate rolling five dice 2000 times and use a histogram to show the distribu-
tion of the sum of each roll.

1 import numpy as np
2 import matplotlib.pyplot as plt
3

4 # Simulate rolling five dice 2000 times

5 num_dice = 5
6 num_rolls = 2000
7 results = np.random.randint(1, 7, (num_rolls, num_dice))
8 sums = np.sum(results, axis=1)
9

10 # Plot the histogram

11 plt.hist(sums, bins=range(5, 31), edgecolor='black')
12 plt.title('Sum Distribution of Rolling Five Dice 2000 Times')
13 plt.xlabel('Sum')
14 plt.ylabel('Frequency')
15 plt.show()

The resulting histogram shows the distribution of the sum of the dice rolls. As seen, the distribution
of the sums forms a bell curve, consistent with the Central Limit Theorem.

Figure 10.4 shows the generated histogram.

 10.2. COMMONLY USED VISUALIZATION CHARTS 143

Sum Distribution of Rolling Five Dice 2000 Times

200
175
150
125
Frequency

100
75
50
25
0
5 10 15 20 25 30
Sum

Figure 10.4: Sum Distribution of Rolling Five Dice 2000 Times

10.2.5 Parallel Coordinates

Parallel coordinate is a method used to visualize multi-dimensional data. Each variable (dimension of
the data) is represented as a vertical axis, and all axes are arranged parallel to each other. Each data
point is represented by a line that connects its value on each axis. By observing these lines, we can
analyze the characteristics of different data points across various variables and identify relationships
and trends within the data.

10.2.6 Iris Dataset

The Iris dataset [29] is a classic dataset in the field of machine learning. It contains three different
species of iris flowers: Iris setosa, Iris versicolor, and Iris virginica. The dataset consists of 150 records,
with each record having four features: sepal length, sepal width, petal length, and petal width. This
dataset is often used for demonstrating classification algorithms.
The following code uses the Iris dataset to plot a parallel coordinates chart, showing the differ-
ences in characteristics between the different species of iris flowers:

1 import pandas as pd
2 import matplotlib.pyplot as plt
3 from pandas.plotting import parallel_coordinates
4 from sklearn.datasets import load_iris
 144 CHAPTER 10. DATA VISUALIZATION

5 import seaborn as sns

6

7 # Load the Iris dataset

8 iris = load_iris()
9 df = pd.DataFrame(iris.data, columns=iris.feature_names)
10 df['species'] = iris.target
11

12 # Map the species from numbers to names

13 df['species'] = df['species'].map({0: 'Setosa', 1: 'Versicolor', 2: 'Virginica'})
14

15 # Set the aesthetic style of the plots

16 sns.set(style="whitegrid")
17

18 # Define a custom color palette

19 palette = sns.color_palette("Set2", 3)
20

21 # Create a figure with a specific size

22 plt.figure(figsize=(14, 8))
23

24 # Plot the parallel coordinates chart with enhanced aesthetics

25 parallel_coordinates(
26 df,
27 'species',
28 color=palette,
29 linewidth=1.5,
30 alpha=0.7
31 )
32

33 # Customize the plot

34 plt.title('Parallel Coordinates Plot of the Iris Dataset', fontsize=18, fontweight='bold', pad=20)
35 plt.xlabel('Features', fontsize=14, labelpad=10)
36 plt.ylabel('Measurements (cm)', fontsize=14, labelpad=10)
37

38 # Customize the ticks

39 plt.xticks(fontsize=12)
40 plt.yticks(fontsize=12)
41

42 # Enhance the legend

43 plt.legend(title='Species', title_fontsize='13', fontsize='11', loc='upper right', frameon=True)
44

45 # Add subtle grid lines

46 plt.grid(True, which='both', linestyle='--', linewidth=0.5, alpha=0.7)
47

48 # Tight layout for better spacing

49 plt.tight_layout()
50

51 # Display the plot

52 plt.show()

Figure 10.5 shows the generated parallel coordinates chart, illustrating the differences in charac-
10.2. COMMONLY USED VISUALIZATION CHARTS 145

teristics between the various species of iris flowers.

3DUDOOHO&RRUGLQDWHV3ORWRIWKH,ULV'DWDVHW
 6SHFLHV
6HWRVD
9HUVLFRORU
 9LUJLQLFD




0HDVXUHPHQWVFP










VHSDOOHQJWKFP VHSDOZLGWKFP SHWDOOHQJWKFP SHWDOZLGWKFP
)HDWXUHV

Figure 10.5: Parallel Coordinates of the Iris Dataset

From the parallel coordinates plot, several patterns in the Iris dataset can be observed:

• Distinctiveness of Setosa: The Setosa species is separated from the other two species (Versi-
color and Virginica) across all feature axes. Specifically, in petal length and petal width, Setosa
has significantly lower values, making it easily distinguishable from the other species.

• Overlap Between Versicolor and Virginica: The lines for Versicolor and Virginica overlap con-
siderably in sepal length and sepal width, making it difficult to differentiate between these two
species based on these features alone. However, there are differences in other features that help
distinguish them.

• Higher Discriminative Power of Petal Features: Although Versicolor and Virginica overlap on
some features, petal length and petal width provide better separation. For instance, Virginia
tends to have larger values in both petal length and width compared to Versicolor.

In summary, Sentosa is easily distinguishable from the other species based on all features, while
Versicolor and Virginica can be more effectively differentiated using petal-related features.

10.2.7 Conclusion
In this section, we explored the importance of data visualization and its critical role in communicating
information. By using charts, graphs, and other visual tools, we can transform complex data into
146 CHAPTER 10. DATA VISUALIZATION

easily comprehensible visual representations, allowing readers to quickly and intuitively grasp the key
insights. As we have seen, effective visualization not only enhances data readability but also reveals
hidden patterns and trends, facilitating deeper analysis.
Moreover, the significance of User Interface (UI) and User Experience (UX) design in the process of
data visualization cannot be overlooked. A well-designed UI ensures that the Graphical User Interface
(GUI) is simple and intuitive, enabling users to interact with data effortlessly. At the same time, strong
UX design guarantees a smooth and satisfying interaction, improving the overall user experience. This
synergy between UI, UX, and data visualization enhances the efficiency of information retrieval and
creates a more engaging and effective way for users to connect with data.
Together, data visualization, UI/UX, and GUI form a cohesive ecosystem. Through thoughtful in-
terface design and interaction experiences, we can fully harness the potential of data, achieving both
efficient information delivery and deeper insights.
In summary, data visualization provides a powerful tool for presenting information more clearly
within complex, diverse environments. The integration of UI/UX and GUI further elevates the quality
of data presentation and interaction. As technology continues to advance, the methods of visualizing
data and designing user interfaces will become more diverse, helping us make better decisions in a
data-driven world.
Conclusion

By studying this book, we believe that you have gained a comprehensive understanding of machine
learning, deep learning, and the related hardware and programming environments. From fundamental
concepts to implementing specific algorithms, from theory to practice, we have aimed to provide you
with a complete learning path. Whether you are a beginner or someone with prior knowledge, this
content should help you better grasp and master the cutting-edge technologies in computer science
today.
However, this is just the beginning. As technology evolves rapidly, the knowledge and applications
in machine learning and deep learning continue to deepen and expand. In future volumes, we will delve
further into more advanced techniques, strategies for model optimization, and the various challenges
and solutions in real-world applications. We look forward to continuing this learning journey with you
as we explore this vast area of technology together.
We hope that by studying this book, you not only gained a fundamental understanding of machine
learning and deep learning but also found inspiration for applying them in practical situations. Let
this book serve as a cornerstone in your journey into the world of intelligent computing, and may it
motivate you to keep moving forward in your future learning and research.

147
148 CHAPTER 10. DATA VISUALIZATION
Bibliography

[1] Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S.
Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew
Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath
Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike
Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent
Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Wattenberg,
Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Tensorflow: Large-scale machine learning on
heterogeneous distributed systems, 2016.

[2] Abien Fred Agarap. Deep learning using rectified linear units (relu), 2019.

[3] Rakesh Agrawal, Tomasz Imieliński, and Arun Swami. Mining association rules between sets
of items in large databases. In Proceedings of the 1993 ACM SIGMOD International Conference
on Management of Data, SIGMOD ’93, page 207–216, New York, NY, USA, 1993. Association for
Computing Machinery.

[4] Amazon. Amazon q developer: Ai-powered coding assistant for aws, 2023.

[5] Amazon Web Services. Amazon SageMaker, 2021. Accessed: 2024-09-28.

[6] Anthropic. Claude: A conversational ai for secure and robust applications, 2023.

[7] Alejandro Barredo Arrieta, Natalia Díaz-Rodríguez, Javier Del Ser, Adrien Bennetot, Siham Tabik,
Alberto Barbado, Salvador García, Sergio Gil-López, Daniel Molina, Richard Benjamins, Raja
Chatila, and Francisco Herrera. Explainable artificial intelligence (xai): Concepts, taxonomies,
opportunities and challenges toward responsible ai, 2019.

[8] David Arthur and Sergei Vassilvitskii. k-means++: The advantages of careful seeding. Proceed-
ings of the Eighteenth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1027–1035,
2007.

[9] Tadas Baltrušaitis, Chaitanya Ahuja, and Louis-Philippe Morency. Multimodal machine learning:
A survey and taxonomy, 2017.

[10] Dor Bank, Noam Koenigstein, and Raja Giryes. Autoencoders, 2021.

[11] Richard Bellman. A markovian decision process. Journal of Mathematics and Mechanics,
6(5):679–684, 1957.

[12] Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new
perspectives, 2014.

149
150 BIBLIOGRAPHY

[13] Christopher M. Bishop. Pattern Recognition and Machine Learning. Springer, 2006.

[14] Avrim Blum and Tom Mitchell. Combining labeled and unlabeled data with co-training. In Pro-
ceedings of the Eleventh Annual Conference on Computational Learning Theory, COLT’ 98, page
92–100, New York, NY, USA, 1998. Association for Computing Machinery.

[15] Leo Breiman. Random forests. Machine Learning, 45(1):5–32, 2001.

[16] Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhari-
wal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel
Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler,
Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott
Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya
Sutskever, and Dario Amodei. Language models are few-shot learners, 2020.

[17] Anna Catherine Cardall, Riley Chad Hales, Kaylee Brooke Tanner, Gustavious Paul Williams, and
Kel N. Markert. Lasso (l1) regularization for development of sparse remote-sensing models with
applications in optically complex waters using gee tools. Remote Sensing, 15(6), 2023.

[18] Varun Chandola, Arindam Banerjee, and Vipin Kumar. Anomaly detection: A survey. ACM Com-
put. Surv., 41(3), July 2009.

[19] Varun Chandola, Arindam Banerjee, and Vipin Kumar. Anomaly detection: A survey. ACM Com-
put. Surv., 41(3), July 2009.

[20] Keyu Chen, Ziqian Bi, Qian Niu, Junyu Liu, Benji Peng, Sen Zhang, Ming Liu, Ming Li, Xuanhe Pan,
Jiawei Xu, Jinlang Wang, and Pohsun Feng. Deep learning and machine learning, advancing big
data analytics and management: Tensorflow pretrained models, 2024.

[21] Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Ka-
plan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen
Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray,
Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bavarian, Clemens Winter,
Philippe Tillet, Felipe Petroski Such, Dave Cummings, Matthias Plappert, Fotios Chantzis, Eliza-
beth Barnes, Ariel Herbert-Voss, William Hebgen Guss, Alex Nichol, Alex Paino, Nikolas Tezak,
Jie Tang, Igor Babuschkin, Suchir Balaji, Shantanu Jain, William Saunders, Christopher Hesse,
Andrew N. Carr, Jan Leike, Josh Achiam, Vedant Misra, Evan Morikawa, Alec Radford, Matthew
Knight, Miles Brundage, Mira Murati, Katie Mayer, Peter Welinder, Bob McGrew, Dario Amodei,
Sam McCandlish, Ilya Sutskever, and Wojciech Zaremba. Evaluating large language models
trained on code, 2021.

[22] Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol-
ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder
for statistical machine translation, 2014.

[23] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. Introduction to
Algorithms. MIT Press, 3rd edition, 2009.

[24] Corinna Cortes and Vladimir Vapnik. Support-vector networks, volume 20. Springer, 1995.

[25] Google DeepMind. Gemini: Multimodal ai for advanced data analysis and reasoning, 2023.
BIBLIOGRAPHY 151

[26] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hier-
archical image database. In 2009 IEEE Conference on Computer Vision and Pattern Recognition,
pages 248–255, 2009.

[27] Soumia Zohra El Mestari, Gabriele Lenzini, and Huseyin Demirci. Preserving data privacy in
machine learning systems. Computers & Security, 137:103605, 2024.

[28] Matthias Feurer, Aaron Klein, Katharina Eggensperger, Jost Springenberg, Manuel Blum, and
Frank Hutter. Efficient and robust automated machine learning. In C. Cortes, N. Lawrence,
D. Lee, M. Sugiyama, and R. Garnett, editors, Advances in Neural Information Processing Systems,
volume 28. Curran Associates, Inc., 2015.

[29] Rory A. Fisher. The use of multiple measurements in taxonomic problems. Annals of Human
Genetics, 7:179–188, 1936.

[30] Santo Fortunato. Community detection in graphs. Physics Reports, 486(3–5):75–174, February
2010.

[31] GitHub. Github copilot: Your ai pair programmer, 2021.

[32] Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward
neural networks. Proceedings of the Thirteenth International Conference on Artificial Intelligence
and Statistics (AISTATS), 9:249–256, 2010.

[33] Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair,
Aaron Courville, and Yoshua Bengio. Generative adversarial networks, 2014.

[34] Google Cloud. Google Cloud AI Platform, 2021. Accessed: 2024-09-28.

[35] Michael Greenacre, Patrick J. F. Groenen, Trevor Hastie, Alfonso Iodice D’Enza, Angelos Markos,
and Elena Tuzhilina. Principal component analysis. Nature Reviews Methods Primers, 2(1):100,
2022.

[36] Charles R. Harris, K. Jarrod Millman, Stéfan J. van der Walt, Ralf Gommers, Pauli Virtanen, David
Cournapeau, Eric Wieser, Julian Taylor, Sebastian Berg, Nathaniel J. Smith, Robert Kern, Matti
Picus, Stephan Hoyer, Marten H. van Kerkwijk, Matthew Brett, Allan Haldane, Jaime Fernández
del Río, Mark Wiebe, Pearu Peterson, Pierre Gérard-Marchant, Kevin Sheppard, Tyler Reddy, War-
ren Weckesser, Hameer Abbasi, Christoph Gohlke, and Travis E. Oliphant. Array programming
with numpy. Nature, 585(7825):357–362, 2020.

[37] Trevor Hastie, Robert Tibshirani, and Jerome Friedman. The Elements of Statistical Learning:
Data Mining, Inference, and Prediction. Springer, 2009.

[38] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing
human-level performance on imagenet classification, 2015.

[39] Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural Computation,
9(8):1735–1780, 1997.

[40] Arthur E Hoerl and Robert W Kennard. Ridge regression: Biased estimation for nonorthogonal
problems. Technometrics, 12(1):55–67, 1970.
152 BIBLIOGRAPHY

[41] John D. Hunter. Matplotlib: A 2d graphics environment. Computing in Science & Engineering,
9(3):90–95, 2007.

[42] Aapo Hyvärinen, Juha Karhunen, and Erkki Oja. Independent Component Analysis. John Wiley &
Sons, 2001.

[43] Anil K. Jain and Richard C. Dubes. Algorithms for Clustering Data. Prentice-Hall, 1988.

[44] Thorsten Joachims. Transductive inference for text classification using support vector ma-
chines. In Proceedings of the Sixteenth International Conference on Machine Learning, ICML
’99, page 200–209, San Francisco, CA, USA, 1999. Morgan Kaufmann Publishers Inc.

[45] Norman P. Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa,
Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, Rick Boyle, Pierre luc Cantin, Clifford Chao,
Chris Clark, Jeremy Coriell, Mike Daley, Matt Dau, Jeffrey Dean, Ben Gelb, Tara Vazir Ghaem-
maghami, Rajendra Gottipati, William Gulland, Robert Hagmann, C. Richard Ho, Doug Hogberg,
John Hu, Robert Hundt, Dan Hurt, Julian Ibarz, Aaron Jaffey, Alek Jaworski, Alexander Kaplan,
Harshit Khaitan, Andy Koch, Naveen Kumar, Steve Lacy, James Laudon, James Law, Diemthu Le,
Chris Leary, Zhuyuan Liu, Kyle Lucke, Alan Lundin, Gordon MacKean, Adriana Maggiore, Maire
Mahony, Kieran Miller, Rahul Nagarajan, Ravi Narayanaswami, Ray Ni, Kathy Nix, Thomas Nor-
rie, Mark Omernick, Narayana Penukonda, Andy Phelps, Jonathan Ross, Matt Ross, Amir Salek,
Emad Samadiani, Chris Severn, Gregory Sizikov, Matthew Snelham, Jed Souter, Dan Steinberg,
Andy Swing, Mercedes Tan, Gregory Thorson, Bo Tian, Horia Toma, Erick Tuttle, Vijay Vasude-
van, Richard Walter, Walter Wang, Eric Wilcox, and Doe Hyun Yoon. In-datacenter performance
analysis of a tensor processing unit, 2017.

[46] L. P. Kaelbling, M. L. Littman, and A. W. Moore. Reinforcement learning: A survey, 1996.

[47] Alex Kendall, Jeffrey Hawke, David Janz, Przemyslaw Mazur, Daniele Reda, John-Mark Allen,
Vinh-Dieu Lam, Alex Bewley, and Amar Shah. Learning to drive in a day, 2018.

[48] Yoon Kim. Convolutional neural networks for sentence classification, 2014.

[49] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization, 2017.

[50] Diederik P Kingma and Max Welling. Auto-encoding variational bayes, 2013.

[51] Teuvo Kohonen. Self-Organizing Maps. Springer, 2001.

[52] Vijay Konda and John Tsitsiklis. Actor-critic algorithms. In S. Solla, T. Leen, and K. Müller, editors,
Advances in Neural Information Processing Systems, volume 12. MIT Press, 1999.

[53] Alex Krizhevsky. Learning multiple layers of features from tiny images, 2009.

[54] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep con-
volutional neural networks. In F. Pereira, C.J. Burges, L. Bottou, and K.Q. Weinberger, editors,
Advances in Neural Information Processing Systems, volume 25. Curran Associates, Inc., 2012.

[55] Martin Krzywinski and Naomi Altman. Classification and regression trees. Nature Methods,
14(8):757–758, 2017.
BIBLIOGRAPHY 153

[56] Y. LeCun, B. Boser, J. S. Denker, D. Henderson, R. E. Howard, W. Hubbard, and L. D. Jackel. Back-
propagation applied to handwritten zip code recognition. Neural Computation, 1(4):541–551,
1989.

[57] Y. Lecun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document
recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.

[58] Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep vi-
suomotor policies, 2015.

[59] J Macqueen. Some methods for classification and analysis of multivariate observations. In
Proceedings of 5-th Berkeley Symposium on Mathematical Statistics and Probability/University
of California Press, 1967.

[60] Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu.
Towards deep learning models resistant to adversarial attacks, 2019.

[61] Hongzi Mao, Mohammad Alizadeh, Ishai Menache, and Srikanth Kandula. Resource manage-
ment with deep reinforcement learning. In Proceedings of the 15th ACM Workshop on Hot Topics
in Networks, HotNets ’16, page 50–56, New York, NY, USA, 2016. Association for Computing Ma-
chinery.

[62] H. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas.
Communication-efficient learning of deep networks from decentralized data, 2023.

[63] Microsoft Azure. Azure Machine Learning, 2021. Accessed: 2024-09-28.

[64] Marvin Minsky and Seymour Papert. Perceptrons: An Introduction to Computational Geometry.
MIT Press, 1969.

[65] Brent Daniel Mittelstadt, Patrick Allo, Mariarosaria Taddeo, Sandra Wachter, and Luciano Floridi.
The ethics of algorithms: Mapping the debate. Big Data & Society, 3(2):2053951716679679,
2016.

[66] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wier-
stra, and Martin Riedmiller. Playing atari with deep reinforcement learning, 2013.

[67] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Belle-
mare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen,
Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra,
Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning.
Nature, 518(7540):529–533, 2015.

[68] Douglas C. Montgomery, Elizabeth A. Peck, and Geoffrey G. Vining. Introduction to Linear Re-
gression Analysis. John Wiley & Sons, 2012.

[69] J. Moody and M. Saffell. Learning to trade via direct reinforcement. IEEE Transactions on Neural
Networks, 12(4):875–889, 2001.

[70] Fionn Murtagh and Pedro Contreras. Algorithms for hierarchical clustering: An overview. Wiley
Interdisciplinary Reviews: Data Mining and Knowledge Discovery, 2(1):86–97, 2012.
154 BIBLIOGRAPHY

[71] Sridhar Narayan. The generalized sigmoid activation function: Competitive supervised learning.
Information Sciences, 99(1):69–82, 1997.

[72] Kamal Nigam, Andrew McCallum, Sebastian Thrun, and Tom Mitchell. Text classification from
labeled and unlabeled documents using em. Machine Learning, 39(2):103–134, 2000.

[73] OpenAI. Chatgpt: September 2023 version, 2023. Large language model.

[74] Keiron O’Shea and Ryan Nash. An introduction to convolutional neural networks, 2015.

[75] Yassine Ouali, Céline Hudelot, and Myriam Tami. An overview of deep semi-supervised learning,
2020.

[76] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan,
Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Köpf,
Edward Yang, Zach DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner,
Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep
learning library, 2019.

[77] Tim Pearce, Alexandra Brintrup, and Jun Zhu. Understanding softmax confidence and uncer-
tainty, 2021.

[78] F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion, O. Grisel, M. Blondel, P. Pretten-

hofer, R. Weiss, V. Dubourg, J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and
E. Duchesnay. Scikit-learn: Machine learning in Python. Journal of Machine Learning Research,
12:2825–2830, 2011.

[79] Benji Peng, Xuanhe Pan, Yizhu Wen, Ziqian Bi, Keyu Chen, Ming Li, Ming Liu, Qian Niu, Junyu Liu,
Jinlang Wang, Sen Zhang, Jiawei Xu, and Pohsun Feng. Deep learning and machine learning,
advancing big data analytics and management: Handy appetizer, 2024.

[80] John Quackenbush. Computational analysis of microarray data. Nature Reviews Genetics,
2(6):418–427, 2001.

[81] Antti Rasmus, Harri Valpola, Mikko Honkala, Mathias Berglund, and Tapani Raiko. Semi-
supervised learning with ladder networks, 2015.

[82] Joseph Redmon, Santosh Divvala, Ross Girshick, and Ali Farhadi. You only look once: Unified,
real-time object detection, 2016.

[83] Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object
detection with region proposal networks, 2015.

[84] Replit. Replit ghostwriter: Ai-powered coding assistance in your browser, 2023.

[85] Francesco Ricci, Lior Rokach, and Bracha Shapira. Introduction to recommender systems hand-
book. In Recommender systems handbook, pages 1–35. Springer, 2011.

[86] F. Rosenblatt. The perceptron: A probabilistic model for information storage and organization
in the brain. Psychological Review, 65(6):386–408, 1958.

[87] G. Rummery and Mahesan Niranjan. On-line q-learning using connectionist systems. Technical
Report CUED/F-INFENG/TR 166, 11 1994.
BIBLIOGRAPHY 155

[88] Robin M. Schmidt. Recurrent neural networks (rnns): A gentle introduction and overview, 2019.

[89] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy
optimization algorithms, 2017.

[90] Dinggang Shen, Guorong Wu, and Heung-Il Suk. Deep learning in medical image analysis. Annual
Review of Biomedical Engineering, 19:221–248, 2017. Epub 2017 Mar 9.

[91] David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche,
Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, Sander Diele-
man, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lillicrap, Madeleine
Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of go with
deep neural networks and tree search. Nature, 529(7587):484–489, 2016.

[92] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale im-
age recognition, 2015.

[93] Jasper Snoek, Hugo Larochelle, and Ryan P. Adams. Practical bayesian optimization of machine
learning algorithms, 2012.

[94] Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov.
Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning
Research, 15(56):1929–1958, 2014.

[95] Richard S. Sutton. Learning to predict by the methods of temporal differences. Machine Learning,
3(1):9–44, 1988.

[96] Richard S. Sutton and Andrew G. Barto. Reinforcement Learning: An Introduction. MIT Press,
2nd edition, 2018.

[97] Richard S Sutton, David McAllester, Satinder Singh, and Yishay Mansour. Policy gradient meth-
ods for reinforcement learning with function approximation. In S. Solla, T. Leen, and K. Müller,
editors, Advances in Neural Information Processing Systems, volume 12. MIT Press, 1999.

[98] Yaniv Taigman, Ming Yang, Marc’Aurelio Ranzato, and Lior Wolf. Deepface: Closing the gap to
human-level performance in face verification. In 2014 IEEE Conference on Computer Vision and
Pattern Recognition, pages 1701–1708, 2014.

[99] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez,
Lukasz Kaiser, and Illia Polosukhin. Attention is all you need, 2017.

[100] Christopher John Cornish Hellaby Watkins and Peter Dayan. Q-learning. Machine Learning, 8(3-
4):279–292, 1992.

[101] Michel Wedel and Wagner A Kamakura. Market Segmentation: Conceptual and Methodological
Foundations. Springer Science & Business Media, 2000.

[102] Wes McKinney. Data Structures for Statistical Computing in Python. In Stéfan van der Walt and
Jarrod Millman, editors, Proceedings of the 9th Python in Science Conference, pages 56 – 61,
2010.
156 BIBLIOGRAPHY

[103] Jianguo (Jeff) Xia, Maia Benner, and Robert Hancock. Networkanalyst - integrative approaches
for protein-protein interaction network analysis and visual exploration. Nucleic acids research,
42, 05 2014.

[104] Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for bench-
marking machine learning algorithms, 2017.

[105] David Yarowsky. Unsupervised word sense disambiguation rivaling supervised methods. In
Proceedings of the 33rd Annual Meeting on Association for Computational Linguistics, ACL ’95,
page 189–196, USA, 1995. Association for Computational Linguistics.

[106] C. Zhang and P. C. Woodland. Dnn speaker adaptation using parameterised sigmoid and relu
hidden activation functions. In 2016 IEEE International Conference on Acoustics, Speech and
Signal Processing (ICASSP), pages 5300–5304, 2016.

[107] Jiawei Zhang. Gradient descent based optimization algorithms for deep learning models train-
ing, 2019.

[108] Xiangyu Zhao, Long Xia, Liang Zhang, Zhuoye Ding, Dawei Yin, and Jiliang Tang. Deep reinforce-
ment learning for page-wise recommendations. In Proceedings of the 12th ACM Conference
on Recommender Systems, RecSys ’18, page 95–103, New York, NY, USA, 2018. Association for
Computing Machinery.

[109] Xiaojin Zhu and Zoubin Ghahramani. Learning from labeled and unlabeled data with label prop-
agation, 2002.