Вы находитесь на странице: 1из 5

Table of Contents

About the Author����������������������������������������������������������������������������������������������������� xi

About the Technical Reviewers����������������������������������������������������������������������������� xiii


Acknowledgments���������������������������������������������������������������������������������������������������xv

Introduction�����������������������������������������������������������������������������������������������������������xvii

Chapter 1: Recognition in Computer Vision�������������������������������������������������������������� 1


Image Recognition Pipeline���������������������������������������������������������������������������������������������������������� 2
Feature Extraction������������������������������������������������������������������������������������������������������������������������� 4
Color Histogram����������������������������������������������������������������������������������������������������������������������� 5
GLCM������������������������������������������������������������������������������������������������������������������������������������� 11
HOG���������������������������������������������������������������������������������������������������������������������������������������� 17
LBP���������������������������������������������������������������������������������������������������������������������������������������� 36
Feature Selection & Reduction��������������������������������������������������������������������������������������������������� 39
Filter�������������������������������������������������������������������������������������������������������������������������������������� 40
Wrapper��������������������������������������������������������������������������������������������������������������������������������� 41
Embedded����������������������������������������������������������������������������������������������������������������������������� 43
Regularization����������������������������������������������������������������������������������������������������������������������� 43

Chapter 2: Artificial Neural Networks��������������������������������������������������������������������� 45


Introduction to ANNs������������������������������������������������������������������������������������������������������������������� 46
Linear Models Are the Base of ANNs������������������������������������������������������������������������������������� 47
Graphing ANNs���������������������������������������������������������������������������������������������������������������������� 52
Adjusting Learning Rate for Training ANN����������������������������������������������������������������������������������� 57
Filter Example������������������������������������������������������������������������������������������������������������������������ 57
Learning Rate������������������������������������������������������������������������������������������������������������������������ 62
Testing the Network�������������������������������������������������������������������������������������������������������������� 63

v
Table of Contents

Weight Optimization Using Backpropagation������������������������������������������������������������������������������ 64


Backpropagation for NN Without Hidden Layer��������������������������������������������������������������������� 64
Weights Update Equation������������������������������������������������������������������������������������������������������ 67
Why Is the Backpropagation Algorithm Important?��������������������������������������������������������������� 69
Forward vs. Backward Passes���������������������������������������������������������������������������������������������� 69
Backpropagation for NN with Hidden Layer�������������������������������������������������������������������������� 77
Overfitting����������������������������������������������������������������������������������������������������������������������������������� 89
Understand Regularization Based on a Regression Example������������������������������������������������ 91
Model Capacity/Complexity��������������������������������������������������������������������������������������������������� 94
L1 Regularization������������������������������������������������������������������������������������������������������������������� 95
Designing ANN���������������������������������������������������������������������������������������������������������������������������� 97
Example 1: ANN Without Hidden Layer���������������������������������������������������������������������������������� 98
Example 2: ANN with a Single Hidden Layer����������������������������������������������������������������������� 102

Chapter 3: Recognition Using ANN with Engineered Features������������������������������ 107


Fruits 360 Dataset Feature Mining�������������������������������������������������������������������������������������������� 107
Feature Mining�������������������������������������������������������������������������������������������������������������������� 108
Feature Reduction��������������������������������������������������������������������������������������������������������������� 115
Filtering Using ANN�������������������������������������������������������������������������������������������������������������� 118
ANN Implementation����������������������������������������������������������������������������������������������������������������� 120
Engineered Feature Limitations������������������������������������������������������������������������������������������������ 126
Not the End of Engineered Features����������������������������������������������������������������������������������������� 127

Chapter 4: ANN Optimization�������������������������������������������������������������������������������� 129


Introduction to Optimization������������������������������������������������������������������������������������������������������ 130
Single- vs. Multiobjective Optimization������������������������������������������������������������������������������� 130
GA���������������������������������������������������������������������������������������������������������������������������������������������� 134
Best-Parents Selection�������������������������������������������������������������������������������������������������������� 137
Variation Operators�������������������������������������������������������������������������������������������������������������� 138
Python Implementation of an Example�������������������������������������������������������������������������������� 140
NSGA-II�������������������������������������������������������������������������������������������������������������������������������������� 151
NSGA-II Steps���������������������������������������������������������������������������������������������������������������������� 152
Dominance�������������������������������������������������������������������������������������������������������������������������� 154
vi
Table of Contents

Crowding Distance�������������������������������������������������������������������������������������������������������������� 162


Tournament Selection���������������������������������������������������������������������������������������������������������� 165
Crossover����������������������������������������������������������������������������������������������������������������������������� 166
Mutation������������������������������������������������������������������������������������������������������������������������������ 167
Optimizing ANN Using GA���������������������������������������������������������������������������������������������������������� 168
Complete Python Implementation��������������������������������������������������������������������������������������� 173

Chapter 5: Convolutional Neural Networks����������������������������������������������������������� 183


From ANN to CNN���������������������������������������������������������������������������������������������������������������������� 183
The Intuition Behind DL������������������������������������������������������������������������������������������������������� 184
Derivation of Convolution���������������������������������������������������������������������������������������������������� 188
Designing a CNN������������������������������������������������������������������������������������������������������������������ 198
Pooling Operation for Parameter Reduction������������������������������������������������������������������������ 202
Convolution Operation Example������������������������������������������������������������������������������������������� 204
Max Pooling Operation Example������������������������������������������������������������������������������������������ 206
Building a CNN Using NumPy from Scratch������������������������������������������������������������������������������ 207
Reading the Input Image����������������������������������������������������������������������������������������������������� 208
Preparing Filters������������������������������������������������������������������������������������������������������������������ 209
Conv Layer��������������������������������������������������������������������������������������������������������������������������� 209
ReLU Layer�������������������������������������������������������������������������������������������������������������������������� 215
Max Pooling Layer��������������������������������������������������������������������������������������������������������������� 216
Stacking Layers������������������������������������������������������������������������������������������������������������������� 218
Complete Code�������������������������������������������������������������������������������������������������������������������� 220

Chapter 6: TensorFlow Recognition Application��������������������������������������������������� 229


Introduction to TF���������������������������������������������������������������������������������������������������������������������� 229
Tensor���������������������������������������������������������������������������������������������������������������������������������� 231
TF Core�������������������������������������������������������������������������������������������������������������������������������� 231
Dataflow Graph�������������������������������������������������������������������������������������������������������������������� 232
Graph Visualization Using TB����������������������������������������������������������������������������������������������� 245
Linear Model������������������������������������������������������������������������������������������������������������������������ 248

vii
Table of Contents

Building FFNN��������������������������������������������������������������������������������������������������������������������������� 255


Linear Classification������������������������������������������������������������������������������������������������������������ 256
Nonlinear Classification������������������������������������������������������������������������������������������������������� 265
CIFAR10 Recognition Using CNN����������������������������������������������������������������������������������������������� 270
Preparing Training Data������������������������������������������������������������������������������������������������������� 271
Building the CNN����������������������������������������������������������������������������������������������������������������� 273
Training CNN������������������������������������������������������������������������������������������������������������������������ 278
Saving the Trained Model���������������������������������������������������������������������������������������������������� 281
Complete Code to Build and Train CNN�������������������������������������������������������������������������������� 282
Preparing Test Data������������������������������������������������������������������������������������������������������������� 292
Testing the Trained CNN Model�������������������������������������������������������������������������������������������� 293

Chapter 7: Deploying Pretrained Models�������������������������������������������������������������� 295


Application Overview���������������������������������������������������������������������������������������������������������������� 295
Introduction to Flask����������������������������������������������������������������������������������������������������������������� 296
route() Decorator����������������������������������������������������������������������������������������������������������������� 298
add_rule_url Method����������������������������������������������������������������������������������������������������������� 301
Variable Rules���������������������������������������������������������������������������������������������������������������������� 301
Endpoint������������������������������������������������������������������������������������������������������������������������������ 303
HTML Form�������������������������������������������������������������������������������������������������������������������������� 305
File Upload��������������������������������������������������������������������������������������������������������������������������� 307
HTML Inside Flask Application��������������������������������������������������������������������������������������������� 309
Static Files��������������������������������������������������������������������������������������������������������������������������� 314
Deploying Trained Model Using Fruits 360 Dataset������������������������������������������������������������������� 317
Deploying Trained Model Using CIFAR10 Dataset��������������������������������������������������������������������� 326

Chapter 8: Cross-Platform Data Science Applications����������������������������������������� 339


Introduction to Kivy������������������������������������������������������������������������������������������������������������������� 340
Basic Application Using BoxLayout������������������������������������������������������������������������������������� 341
Kivy Application Life Cycle��������������������������������������������������������������������������������������������������� 342
Widget Size�������������������������������������������������������������������������������������������������������������������������� 346
GridLayout��������������������������������������������������������������������������������������������������������������������������� 348
More Widgets����������������������������������������������������������������������������������������������������������������������� 350

viii
Table of Contents

Widget Tree�������������������������������������������������������������������������������������������������������������������������� 351


Handling Events������������������������������������������������������������������������������������������������������������������� 354
KV Language������������������������������������������������������������������������������������������������������������������������ 356
P4A�������������������������������������������������������������������������������������������������������������������������������������������� 361
Installing Buildozer�������������������������������������������������������������������������������������������������������������� 361
Preparing buildozer.spec File���������������������������������������������������������������������������������������������� 362
Building Android Application Using Buildozer���������������������������������������������������������������������� 365
Image Recognition on Android�������������������������������������������������������������������������������������������������� 367
CNN on Android������������������������������������������������������������������������������������������������������������������������� 373

Appendix A: Installing Your Own Projects Using pip Installer������������������������������ 381


Creating a Simple Python Project��������������������������������������������������������������������������������������������� 382
Project Structure����������������������������������������������������������������������������������������������������������������������� 382
Project Implementation������������������������������������������������������������������������������������������������������������� 382
Running the Project������������������������������������������������������������������������������������������������������������������ 383
Importing the Module into a File Inside Its Directory���������������������������������������������������������������� 384
Importing the Module into a File Outside Its Directory������������������������������������������������������������� 384
How Does Python Locate Libraries?����������������������������������������������������������������������������������������� 386
Manual Installation by Copying Project Files to Site-­Packages������������������������������������������������ 387
How Do Python Installers Locate Libraries?����������������������������������������������������������������������������� 388
Preparing the Package and Its Files (__init__.py and setup.py)����������������������������������������������� 388
__init__.py�������������������������������������������������������������������������������������������������������������������������������� 389
setup.py������������������������������������������������������������������������������������������������������������������������������������ 390
Distributing the Package����������������������������������������������������������������������������������������������������������� 391
Uploading the Distribution Files Online to Test PyPI������������������������������������������������������������������ 393
Installing the Distributed Package from Test PyPI�������������������������������������������������������������������� 395
Importing and Using the Installed Package������������������������������������������������������������������������������ 396
Using PyPI Rather Than Test PyPI���������������������������������������������������������������������������������������������� 396

Index��������������������������������������������������������������������������������������������������������������������� 397

ix