# Index

## A

- activation functions
- about / Activation functions
- sigmoid / Sigmoid
- hyperbolic tangent function / The hyperbolic tangent function
- Rectified Linear Unit (ReLU) / The Rectified Linear Unit (ReLU)

- adjacency matrix / Label propagation
- Adjusted Rand Index / Adjusted Rand Index
- adversarial examples / Adversarial examples
- affine transformation / Spatial transformer networks
- affinity matrix / Label propagation
- AlexNet model / The AlexNet model
- algorithms
- localizing / Localizing algorithms
- objects localizing, sliding windows used / Localizing objects using sliding windows
- regression / Thinking about localization as a regression problem

- Amazon Web Services (AWS) / Development environment setup
- application areas, RNNs
- Natural Language Modeling / Application areas of RNNs
- Voice and Speech Recognition / Application areas of RNNs
- Image/Video Description or Caption Generation / Application areas of RNNs
- TimeSeries Data / Application areas of RNNs

- approaches, spectral clustering
- k-Nearest Neighbors (KNN) / Spectral clustering
- radial basis function (RBF) / Spectral clustering

- approximate nearest neighbor oh yeah (ANNOY)
- about / Matching faster using approximate nearest neighbour
- advantages / Advantages of ANNOY

- artificial neural network (ANN)
- about / Understanding deep learning, Artificial neural network (ANN)
- one-hot encoding / One-hot encoding
- softmax / Softmax
- cross-entropy / Cross-entropy
- dropout / Dropout
- batch normalization / Batch normalization
- L1 regularization / L1 and L2 regularization
- L2 regularization / L1 and L2 regularization
- training / Training neural networks
- backpropagation / Backpropagation
- gradient descent / Gradient descent
- stochastic gradient descent (SGD) / Stochastic gradient descent

- artificial neuron / The perceptron
- assumptions, semi-supervised model
- smoothness assumption / Smoothness assumption
- cluster assumption / Cluster assumption
- manifold assumption / Manifold assumption

- Asynchronous Update / Strategies for distributed execution
- atrous convolution / Atrous convolution, Sampling the layers by convolution
- augmentation techniques
- about / Augmentation techniques
- flipping / Augmentation techniques
- random cropping / Augmentation techniques
- shearing / Augmentation techniques
- zooming / Augmentation techniques
- rotation / Augmentation techniques
- whitening / Augmentation techniques
- normalization / Augmentation techniques
- channel shifting / Augmentation techniques

- autoencoder
- denoising, in TensorFlow / Denoising autoencoder in TensorFlow
- denoising, in Keras / Denoising autoencoder in Keras

- autoencoders
- used, for image denoising / Denoising using autoencoders

- autoencoder types
- simple autoencoder / Autoencoder types
- sparse autoencoder / Autoencoder types
- Denoising autoencoder (DAE) / Autoencoder types
- Convolutional autoencoder (CAE) / Autoencoder types
- Variational autoencoder (VAE) / Autoencoder types

- average pooling / Pooling layers

## B

- backpropagation / Training neural networks, Backpropagation
- backpropagation through time (BPTT) / Backpropagation through time (BPTT)
- Ball Trees / Ball Trees
- batch normalization / Batch normalization
- Bayes' theorem / Conditional probabilities and Bayes' theorem
- Bayes accuracy / Underfitting
- Bayesian network
- about / Bayesian networks
- sampling from / Sampling from a Bayesian network
- direct sampling / Direct sampling
- Markov chains / A gentle introduction to Markov chains
- Gibbs sampling / Gibbs sampling
- Metropolis-Hastings sampling / Metropolis-Hastings sampling

- bidimensional discrete convolutions
- about / Bidimensional discrete convolutions
- padding / Strides and padding
- strides / Strides and padding

- Bidirectional RNN (BRNN) / RNN variants
- binary classification / Label propagation based on Markov random walks
- logistic regression / Logistic regression for binary classification
- about / Binary classification

- bottleneck features
- training / Training on bottleneck features

- bottleneck layer / Autoencoders of raw images
- brute-force algorithm / k-Nearest Neighbors

## C

- candidate-generating distribution / Metropolis-Hastings sampling
- capacity, models
- defining / Capacity of a model
- Vapnik-Chervonenkis capacity /

- cartpole game
- reference / OpenAI Gym 101
- simple policies, applying / Applying simple policies to a cartpole game

- categorical cross-entropy / Categorical cross-entropy
- cells / RNN variants
- chain rule of probabilities / Conditional probabilities and Bayes' theorem
- Chapman-Kolmogorov / A gentle introduction to Markov chains
- CIFAR10
- ConvNets, using with TensorFlow / ConvNets for CIFAR10 with TensorFlow
- ConvNets, using with Keras / ConvNets for CIFAR10 with Keras

- CIFAR10 Data
- LeNet / LeNet for CIFAR10 Data

- classification
- logistic regression, using / Classification using logistic regression

- class rebalancing / Example of label propagation based on Markov random walks
- COCO object detection challenge / COCO object detection challenge
- Common Objects in Context (COCO) / COCO object detection challenge
- completeness score / Completeness score
- Computed Tomography (CT) / Diagnosing medical images
- Computer Unified Device Architecture (CUDA) / Computer Unified Device Architecture - CUDA
- conditional independence / Conditional probabilities and Bayes' theorem
- conditional probability / Conditional probabilities and Bayes' theorem
- conditional random field (CRF) / DeepLab
- conditions
- asserting, on with tf.Assert() function / Asserting on conditions with tf.Assert()

- connected layer
- training, as convolution layer / Training a fully connected layer as a convolution layer

- consistent estimator / Bias of an estimator
- constant error carousel (CEC) / LSTM
- Constraint Optimization by Linear Approximation (COBYLA) / Example of S3VM
- content-based image retrieval (CBIR)
- about / Content-based image retrieval
- Locality sensitive hashing (LSH) / Content-based image retrieval
- multi-index hashing / Content-based image retrieval
- geometric verification / Content-based image retrieval
- query expansion / Content-based image retrieval
- relevance feedback / Content-based image retrieval
- retrieval pipeline, building / Building the retrieval pipeline
- efficient retrieval / Efficient retrieval
- autoencoders, used for image denoising / Denoising using autoencoders

- Contrastive Pessimistic Likelihood Estimation (CPLE) algorithm
- ConvNets
- training, with TensorFlow / ConvNets for CIFAR10 with TensorFlow
- training, with Keras / ConvNets for CIFAR10 with Keras

- Convolution
- about / Understanding convolution
- reference / Understanding convolution

- convolutional LSTM / LSTM
- convolutional neural networks (CNN)
- about / Convolutional neural network
- kernel / Kernel
- max pooling / Max pooling

- convolution implementation
- of sliding window / Convolution implementation of sliding window

- convolutions
- about / Convolutions
- bidimensional discrete convolutions / Bidimensional discrete convolutions
- separable convolution / Separable convolution
- transpose convolution / Transpose convolution

- cost function
- about / Loss and cost functions
- starting point / Loss and cost functions
- local minima / Loss and cost functions
- ridges/local maxima / Loss and cost functions
- plateaus / Loss and cost functions
- global minimum / Loss and cost functions
- examples / Examples of cost functions
- mean squared error / Mean squared error
- Huber cost function / Huber cost function
- Hinge cost function / Hinge cost function
- categorical cross-entropy / Categorical cross-entropy
- regularization / Regularization

- covariance rule
- about / Hebb's rule
- analysis / Analysis of the covariance rule
- application, example / Example of covariance rule application
- example / Example of covariance rule application

- Cramér-Rao bound / The Cramér-Rao bound
- cross-entropy / Cross-entropy
- cross-validation / Cross-validation
- CUDA Deep Neural Network (CUDNN)
- about / CUDA Deep Neural Network - CUDNN
- URL, for downloading / CUDA Deep Neural Network - CUDNN

- CUDA library
- URL, for downloading / Computer Unified Device Architecture - CUDA

## D

- data / Models and data
- preparing / Preparing the data

- data generating process / Models and data
- data parallel strategy
- In-Graph Replication / Strategies for distributed execution
- Between-Graph Replication / Strategies for distributed execution

- datasets
- augmenting / Augmenting the dataset
- augmentation techniques / Augmentation techniques
- exploring / Exploring the datasets
- PASCAL VOC challenge / PASCAL VOC challenge
- COCO object detection challenge / COCO object detection challenge
- evaluating, metrics used / Evaluating datasets using metrics
- Intersection over Union (IoU) / Intersection over Union
- mean average precision / The mean average precision

- decoder / Autoencoders of raw images
- deconvolution / Sampling the layers by convolution
- Deep Bidirectional RNN (DBRNN) / RNN variants
- Deep Convolutional GAN
- with TensorFlow / Deep Convolutional GAN with TensorFlow and Keras
- with Keras / Deep Convolutional GAN with TensorFlow and Keras

- deep convolutional network, with data augmentation
- deep convolutional network, with Keras
- deep convolutional networks
- about / Deep convolutional networks
- convolutions / Convolutions
- pooling layers / Pooling layers
- padding layers / Other useful layers
- upsampling layers / Other useful layers
- cropping layers / Other useful layers
- flattening layers / Other useful layers

- DeepDream / The DeepDream
- DeepLab / DeepLab
- DeepLab v3 / DeepLab v3
- deep learning
- about / Understanding deep learning
- perceptron / Perceptron
- activation functions / Activation functions
- artificial neural network (ANN) / Artificial neural network (ANN)
- artificial neural network (ANN), training / Training neural networks
- TensorFlow playground, playing / Playing with TensorFlow playground
- convolutional neural networks (CNN) / Convolutional neural network
- recurrent neural networks (RNN) / Recurrent neural networks (RNN)
- long short-term memory (LSTM) / Long short-term memory (LSTM)
- for computer vision / Deep learning for computer vision
- classification / Classification
- detection or localization / Detection or localization and segmentation
- segmentation / Detection or localization and segmentation
- similarity learning / Similarity learning
- image captioning / Image captioning
- generative models / Generative models
- video analysis / Video analysis

- deep learning models
- about / The bigger deep learning models
- AlexNet model / The AlexNet model
- VGG-16 model / The VGG-16 model
- Google Inception-V3 model / The Google Inception-V3 model
- Microsoft ResNet-50 model / The Microsoft ResNet-50 model
- SqueezeNet model / The SqueezeNet model
- spatial transformer networks / Spatial transformer networks
- DenseNet model / The DenseNet model

- DeepNet model / The DeepNet model
- Deep Neural Networks (DNN) / MultiLayer Perceptron
- Deep Q Network (DQN)
- Q-Learning / Q-Learning with Q-Network or Deep Q Network (DQN)

- DeepRank / DeepRank
- degree matrix / Label propagation
- DenseNet model / The DenseNet model
- depth multiplier / Separable convolution
- depthwise separable convolution / Separable convolution
- development environment
- setting up / Development environment setup
- hardware / Hardware and Operating Systems - OS
- operating systems / Hardware and Operating Systems - OS
- software packages, installing / Installing software packages

- Development Operating Systems(OS) / Development environment setup
- Dijkstra algorithm / Isomap
- dilated convolution / Atrous convolution, Sampling the layers by convolution, Dilated convolutions
- direct sampling
- about / Direct sampling
- example / Example of direct sampling

- discrete Laplacian operator / Bidimensional discrete convolutions
- Docker containers
- TF Serving / TF Serving in the Docker containers
- installing / Installing Docker
- model, serving / Serving the model in the Docker container

- dockerhub
- Docker image, uploading / Uploading the Docker image to the dockerhub

- Docker image
- building, for TensorFlow Serving (TFS) / Building a Docker image for TF serving
- uploading, to dockerhub / Uploading the Docker image to the dockerhub

- dropout / Dropout
- Dunn's partitioning coefficient / Fuzzy C-means

## E

- early stopping / Early stopping
- efficient retrieval
- about / Efficient retrieval
- approximate nearest neighbor, used for faster matching / Matching faster using approximate nearest neighbour
- raw images, autoencoders / Autoencoders of raw images

- ElasticNet / ElasticNet
- EleasticNet regularization / ElasticNet regularization
- emissions / Hidden Markov Models (HMMs)
- empirical risk / Loss and cost functions
- encoder / Content-based image retrieval, Autoencoders of raw images
- entropy function
- reference / TensorFlow-based MLP for MNIST classification

- estimator
- bias, measuring / Bias of an estimator
- underfitting / Underfitting
- variance, measuring / Variance of an estimator
- overfitting / Overfitting
- Cramér-Rao bound / The Cramér-Rao bound

- Euclidean distance / Computing similarity between query image and target database
- evaluation metrics
- about / Evaluation metrics
- homogeneity score / Homogeneity score
- completeness score / Completeness score
- Adjusted Rand Index / Adjusted Rand Index
- silhouette score / Silhouette score

- Expectation Maximization (EM) algorithm
- about / Models and data, EM algorithm
- parameter estimation, example / An example of parameter estimation

- expected risk / Loss and cost functions

## F

- face clustering / Face clustering
- Face Detection Data Set and Benchmark (FDDB) / Face detection
- face landmarks
- Multi-Task Facial Landmark (MTFL) dataset / The Multi-Task Facial Landmark (MTFL) dataset
- Kaggle keypoint dataset / The Kaggle keypoint dataset
- Multi-Attribute Facial Landmark (MAFL) dataset / The Multi-Attribute Facial Landmark (MAFL) dataset
- facial key points, learning / Learning the facial key points

- FaceNet
- about / FaceNet
- face verification / FaceNet
- face recognition / FaceNet
- face clustering / FaceNet
- triplet loss / Triplet loss

- face pose / Face landmarks and attributes
- face recognition
- about / Face recognition
- labeled faces, in LFW dataset / The labeled faces in the wild (LFW) dataset
- YouTube faces dataset / The YouTube faces dataset
- CelebFaces Attributes dataset (CelebA) / The CelebFaces Attributes dataset (CelebA)
- CASIA web face database / CASIA web face database
- VGGFace2 dataset / The VGGFace2 dataset
- similarity between faces, computing / Computing the similarity between faces
- optimum threshold, finding / Finding the optimum threshold

- facial keypoints
- about / Face landmarks and attributes
- learning / Learning the facial key points

- facial keypoints detection
- URL, for downloading / The Kaggle keypoint dataset

- factor analysis (FA) / Factor analysis
- factor analysis (FA), with Scikit-Learn
- FastICA with Scikit-Learn
- example / An example of FastICA with Scikit-Learn

- Fast R-CNN / Fast R-CNN, Faster R-CNN
- FCN
- modeling, for segmentation / Modeling FCN for segmentation

- feature map / Convolutions
- feed forward neural networks (FFNN) / MultiLayer Perceptron
- fiducial point detection / Applying regression to other problems
- fiducial points / Face landmarks and attributes
- fine-tuning / Fine-tuning several layers in deep learning
- Fisher information / The Cramér-Rao bound
- forward-backward algorithm
- about / Forward-backward algorithm
- forward phase / Forward phase
- backward phase / Backward phase
- HMM parameter estimation / HMM parameter estimation

- fractionally strided convolution / Sampling the layers by convolution
- Fully Convolutional Network (FCN) / The Fully Convolutional Network
- fuzzy C-means / Fuzzy C-means
- fuzzy C-means, with Scikit-Fuzzy
- fuzzy logic / Fuzzy C-means

## G

- Gated recurrent unit (GRU) / GRU
- Gated Recurrent Unit (GRU)
- about / RNN variants, GRU network

- Gaussian mixture / Gaussian mixture
- Gaussian mixture, with Scikit-Learn
- Generalized Hebbian Rule (GHA) / Sanger's network
- General Purpose - Graphics Processing Unit (GP-GPU)
- about / Hardware and Operating Systems - OS, General Purpose - Graphics Processing Unit (GP-GPU)
- Computer Unified Device Architecture (CUDA) / Computer Unified Device Architecture - CUDA
- CUDA Deep Neural Network (CUDNN) / CUDA Deep Neural Network - CUDNN

- Generative Adversarial Networks (GAN)
- about / Generative Adversarial Networks 101
- reference / Generative Adversarial Networks 101
- TensorFlow, using / Simple GAN with TensorFlow
- Keras, using / Simple GAN with Keras

- Generative Gaussian mixtures
- about / Generative Gaussian mixtures
- example / Example of a generative Gaussian mixture
- weighted log-likelihood / Weighted log-likelihood

- Gibbs sampling / Gibbs sampling
- Google Cloud Platform (GCP) / Development environment setup
- Google Inception-V3 model / The Google Inception-V3 model
- gradient descent
- reference / Defining the optimizer function

- Gram-Schmidt / Sanger's network
- Graphics Processing Unit (GPU) / Preparing the data
- graph variables
- saving, with saver class / Saving and restoring all graph variables with the saver class
- restoring, with saver class / Saving and restoring all graph variables with the saver class

- ground truth / Evaluating datasets using metrics, Intersection over Union

## H

- hard negative mining / Triplet loss
- hardware / Hardware and Operating Systems - OS
- Hebb's rule / Hebb's rule
- Hidden Markov Models (HMMs)
- about / Hidden Markov Models (HMMs), Addendum to HMMs
- forward-backward algorithm / Forward-backward algorithm
- Viterbi algorithm / Viterbi algorithm

- Hinge cost function / Hinge cost function
- hmmlearn
- reference link / Example of HMM training with hmmlearn
- most likely hidden state sequence, finding / Finding the most likely hidden state sequence with hmmlearn

- HMM parameter estimation / HMM parameter estimation
- HMM training
- hmmlearn / Example of HMM training with hmmlearn

- homogeneity score / Homogeneity score
- Huber cost function / Huber cost function
- human face analysis
- about / Human face analysis
- face detection / Face detection
- face landmarks / Face landmarks and attributes
- attributes / Face landmarks and attributes
- face recognition / Face recognition
- face clustering / Face clustering

- hyperbolic tangent / The perceptron
- hyperbolic tangent function / The hyperbolic tangent function

## I

- image classification
- multilayer perceptron / MLP for image classification

- ImageNet dataset / ImageNet dataset
- Inception-V3 / The Google Inception-V3 model
- independent and identically distributed (i.i.d.) / Models and data
- independent component analysis / Independent component analysis
- inductive learning / Inductive learning
- inference / Model inference
- instance-based learning / k-Nearest Neighbors
- instance segmentation / Predicting pixels
- International Society for Photogrammetry and Remote Sensing (ISPRS) / Segmenting satellite images
- Intersection over Union (IoU) / Evaluating datasets using metrics, Intersection over Union
- Isomap algorithm
- about / Isomap
- example / Example of Isomap

## K

- K-Fold cross-validation
- about / Cross-validation
- Stratified K-Fold / Cross-validation
- Leave-one-out (LOO) / Cross-validation
- Leave-P-out (LPO) / Cross-validation

- K-means / K-means
- K-means++ / K-means++
- K-means, with Scikit-Learn
- example / Example of K-means with Scikit-Learn

- k-Nearest Neighbors (KNN)
- about / k-Nearest Neighbors
- KD Trees / KD Trees
- Ball Trees / Ball Trees

- kaggle
- about / Preparing the data
- URL / Preparing the data

- Kaggle keypoint dataset / The Kaggle keypoint dataset
- KD Trees / KD Trees
- Keras
- for RNN / Keras for RNN
- RNN, for MNIST data / RNN in Keras for MNIST data
- stacked autoencoder / Stacked autoencoder in Keras
- autoencoder, denoising / Denoising autoencoder in Keras
- variational autoencoder / Variational autoencoder in Keras
- using, in Deep Convolutional GAN / Deep Convolutional GAN with TensorFlow and Keras

- Keras library / The Keras library
- Keras model
- restoring / Saving and restoring Keras models
- saving / Saving and restoring Keras models

- kernel / Kernel
- KNN, with Scikit-Learn
- example / Example of KNN with Scikit-Learn

- Kohonen / Self-organizing maps
- Kubernetes
- TensorFlow Serving (TFS) / TensorFlow Serving on Kubernetes
- reference / TensorFlow Serving on Kubernetes
- installing / Installing Kubernetes
- deployment / Deploying in Kubernetes

## L

- L1 regularization / L1 and L2 regularization
- label propagation
- about / Label propagation
- example / Example of label propagation

- label propagation, based on Markov random walks
- label spreading
- about / Label spreading
- example / Example of label spreading

- Laplacian Spectral Embedding
- about / Laplacian Spectral Embedding
- example / Example of Laplacian Spectral Embedding

- large kernel matters / Large kernel matters
- Lasso regularization / Lasso, Lasso regularization
- Latent Dirichlet Allocation (LDA) / MLE and MAP learning
- layers
- fine-tuning, in deep learning / Fine-tuning several layers in deep learning

- Leave-one-out (LOO) / Cross-validation
- Leave-P-out (LPO) / Cross-validation
- LeNet
- about / CNN architecture pattern - LeNet
- reference / CNN architecture pattern - LeNet
- for MNIST Data / LeNet for MNIST data
- for CIFAR10 Data / LeNet for CIFAR10 Data

- LeNet CNN
- building, for MNIST data with TensorFlow / LeNet CNN for MNIST with TensorFlow
- building, for MNIST with Keras / LeNet CNN for MNIST with Keras

- likelihood / Conditional probabilities and Bayes' theorem
- linear regression
- about / Simple linear regression
- data preparation / Data preparation
- model, building / Building a simple regression model

- Lloyd's algorithm / K-means
- Locally Linear Embedding (LLE)
- about / Locally linear embedding
- example / Example of locally linear embedding

- Local Response Normalization (LRN) / The AlexNet model
- logistic regression
- used, for classification / Classification using logistic regression
- for binary classification / Logistic regression for binary classification
- multiclass classification / Logistic regression for multiclass classification

- long-short-term memory (LSTM) / LSTM
- long-term depression (LTD) / Hebb's rule
- long-term potentiation (LTP) / Hebb's rule
- long short-term memory (LSTM) / Long short-term memory (LSTM)
- Long Short-Term Memory (LSTM) network / RNN variants, LSTM network
- loss function
- about / Loss and cost functions
- defining / Loss and cost functions

- LSTM network, with Keras
- example / Example of an LSTM network with Keras

## M

- Magnetic Resonance Imaging (MRI) / Diagnosing medical images
- manifold learning
- about / Manifold learning
- Isomap algorithm / Isomap
- Locally Linear Embedding (LLE) / Locally linear embedding

- Markov chains / A gentle introduction to Markov chains
- Mask RCNN / Segmenting instances
- Maximum A Posteriori (MAP) learning / MLE and MAP learning
- Maximum Likelihood Estimation (MLE) learning / MLE and MAP learning, Hebb's rule
- max pooling / Pooling layers, Max pooling
- mean average precision / The mean average precision
- Mean Precision Average (mAP) / Evaluating datasets using metrics
- mean squared error / Mean squared error
- mean squared error (mse) / Defining the loss function
- memory replay / Q-Learning with Q-Network or Deep Q Network (DQN)
- metric multidimensional scaling / Isomap
- Metropolis-Hastings sampling
- about / Metropolis-Hastings sampling
- example / Example of Metropolis-Hastings sampling

- Microsoft ResNet-50 model / The Microsoft ResNet-50 model
- MLLE
- reference link / Locally linear embedding

- MNIST classification
- MLP, using / TensorFlow-based MLP for MNIST classification

- MNIST data
- RNN in Keras / RNN in Keras for MNIST data
- LeNet / LeNet for MNIST data
- LeNet CNN, building with TensorFlow / LeNet CNN for MNIST with TensorFlow
- LeNet CNN, building with Keras / LeNet CNN for MNIST with Keras

- model
- training / Training a model for cats versus dogs
- data, preparing / Preparing the data
- simple CNN, benchmarking / Benchmarking with simple CNN
- dataset, augmenting / Augmenting the dataset
- transfer learning / Transfer learning or fine-tuning of a model
- fine-tuning / Transfer learning or fine-tuning of a model
- bottleneck features, training / Training on bottleneck features
- layers, fine-tuning, in deep learning / Fine-tuning several layers in deep learning
- layers, fine-tuning in deep learning / Fine-tuning several layers in deep learning

- model inference
- about / Model inference
- exporting / Exporting a model
- trained model, serving / Serving the trained model

- models
- about / Models and data, TensorFlow Serving
- zero-centering / Zero-centering and whitening
- whitening / Zero-centering and whitening
- training set / Training and validation sets
- validation set / Training and validation sets
- cross-validation / Cross-validation
- saving / Saving and Restoring models in TensorFlow
- restoring / Saving and Restoring models in TensorFlow

- models, features
- about / Features of a machine learning model
- capacity, defining / Capacity of a model
- estimator bias, measuring / Bias of an estimator
- estimator variance, measuring / Variance of an estimator

- Modified LLE / Locally linear embedding
- MSE
- reference / Defining the loss function

- Multi-Attribute Facial Landmark (MAFL) dataset / The Multi-Attribute Facial Landmark (MAFL) dataset
- URL, for downloading / The Multi-Attribute Facial Landmark (MAFL) dataset

- Multi-Attribute Labelled Faces (MALF) / Face detection
- multi-regression / Multi-regression
- Multi-Task Facial Landmark (MTFL) dataset / The Multi-Task Facial Landmark (MTFL) dataset
- multiclass classification
- logistic regression / Logistic regression for multiclass classification
- about / Multiclass classification

- multidimensional regression / Multi-regression
- Multilayer Perceptron (MLP)
- about / MultiLayer Perceptron
- used, for image classification / MLP for image classification
- building, with TensorFlow-based code / TensorFlow-based MLP for MNIST classification, Summary of MLP with TensorFlow, Keras, and TFLearn
- Keras-based code / Keras-based MLP for MNIST classification
- building, with TFLearn-based code / TFLearn-based MLP for MNIST classification, Summary of MLP with TensorFlow, Keras, and TFLearn
- building, with Keras-based code / Summary of MLP with TensorFlow, Keras, and TFLearn
- used, for time series regression / MLP for time series regression

## N

- neural nets / Activation functions
- non-parametric models / Models and data

## O

- object detection API
- about / Object detection API
- installing / Installation and setup
- setting up / Installation and setup
- pre-trained models / Pre-trained models
- re-training object detection models / Re-training object detection models
- pedestrian detection, training for self-driving car / Training a pedestrian detection for a self-driving car

- object localization / Detecting objects in an image
- objects
- detecting, in an image / Detecting objects in an image
- localizing, sliding windows used / Localizing objects using sliding windows
- scale-space concept / The scale-space concept
- connected layer, training as convolution layer / Training a fully connected layer as a convolution layer
- convolution implementation, of sliding window / Convolution implementation of sliding window
- detecting / Detecting objects
- Regions of the convolutional neural network (R-CNN) / Regions of the convolutional neural network (R-CNN)
- Fast R-CNN / Fast R-CNN, Faster R-CNN
- Single shot multi-box detector / Single shot multi-box detector

- Occam's razor principle / The Cramér-Rao bound
- Oja's rule / Weight vector stabilization and Oja's rule
- one-hot encoding / One-hot encoding
- one-shot learning / Siamese networks
- OpenAI Gym
- about / OpenAI Gym 101
- reference / OpenAI Gym 101

- Open Computer Vision (OpenCV)
- operating systems
- about / Hardware and Operating Systems - OS
- General Purpose - Graphics Processing Unit (GP-GPU) / General Purpose - Graphics Processing Unit (GP-GPU)

- optimization / Training neural networks
- Ordinary Least Squares (OLS) / Ridge
- overfitting / Overfitting, Regularized regression

## P

- pandas
- reference link / Example of an LSTM network with Keras

- parametric models / Models and data
- PASCAL VOC challenge
- about / PASCAL VOC challenge
- URL, for downloading / PASCAL VOC challenge

- PCA with Scikit-Learn
- example / An example of PCA with Scikit-Learn
- about / An example of PCA with Scikit-Learn

- pedestrain detection
- training, for self-driving car / Training a pedestrian detection for a self-driving car

- peephole LSTM / LSTM
- perceptron / The perceptron
- about / Perceptron

- pip3 / Python
- pixels
- predicting / Predicting pixels
- medical images, diagnosing / Diagnosing medical images
- satellite imagery / Understanding the earth from satellite imagery
- robots, enabling / Enabling robots to see

- point of inflection / Loss and cost functions
- policy search / V function (learning to optimize when the model is available)
- pooling
- about / Understanding pooling
- reference / Understanding pooling
- layers, reference / Understanding pooling

- pooling layers / Pooling layers
- pose detection / Applying regression to other problems
- principal component analysis (PCA) / Understanding visual features
- Principal Component Analysis (PCA) / Isomap, Principal Component Analysis, Analysis of the covariance rule
- prior probability / Conditional probabilities and Bayes' theorem
- Protocol Buffers (protobuf) / Installation and setup
- PSPnet / PSPnet
- PyMC3
- reference link / Sampling example using PyMC3

- Python / Python

## Q

- Q-Learning
- implementing / Implementing Q-Learning
- discretizing / Initializing and discretizing for Q-Learning
- initializing / Initializing and discretizing for Q-Learning
- using, with Q-Table / Q-Learning with Q-Table
- using, with Deep Q Network (DQN) / Q-Learning with Q-Network or Deep Q Network (DQN)
- using, with Q-Network / Q-Learning with Q-Network or Deep Q Network (DQN)

- Q-Network
- Q-Learning / Q-Learning with Q-Network or Deep Q Network (DQN)

## R

- r-squared (rs) function / Defining the loss function
- Rayleigh-Ritz method / Locally linear embedding
- re-training object detection models
- about / Re-training object detection models
- data preparation, for Pet dataset / Data preparation for the Pet dataset
- object detection training pipeline / Object detection training pipeline
- model, training / Training the model
- loss and accuracy monitoring, TensorBoard used / Monitoring loss and accuracy using TensorBoard

- real-world applications
- developing / Developing real-world applications
- model, selecting / Choosing the right model
- underfitting, tackling / Tackling the underfitting and overfitting scenarios
- scenarios, overfitting / Tackling the underfitting and overfitting scenarios
- gender detection, from face / Gender and age detection from face
- age detection, from face / Gender and age detection from face
- apparel models, fine-tuning / Fine-tuning apparel models
- brand safety / Brand safety

- Rectified Linear Unit / The perceptron
- Rectified Linear Unit (ReLU) / The hyperbolic tangent function, The Rectified Linear Unit (ReLU)
- recurrent networks
- about / Recurrent networks
- backpropagation through time (BPTT) / Backpropagation through time (BPTT)
- long-short-term memory (LSTM) / LSTM
- Gated recurrent unit (GRU) / GRU

- recurrent neural networks (RNN)
- about / Recurrent neural networks (RNN)

- Recurrent Neural Networks (RNNs)
- variants / RNN variants
- TensorFlow, using / TensorFlow for RNN
- reference / TensorFlow RNN Cell Wrapper Classes, Application areas of RNNs
- Keras / Keras for RNN
- application areas / Application areas of RNNs

- Recurrent Neural Networks (RNNs) variants
- about / RNN variants
- bidirectional RNN (BRNN) / RNN variants
- deep bidirectional RNN (DBRNN) / RNN variants
- Long Short-Term Memory (LSTM) / RNN variants
- Gated Recurrent Unit (GRU) / RNN variants
- seq2seq models / RNN variants

- RefiNet / RefiNet
- Region of Interest pooling / Fast R-CNN
- Regions of the convolutional neural network (R-CNN) / Regions of the convolutional neural network (R-CNN)
- regression
- about / Thinking about localization as a regression problem
- applying / Applying regression to other problems
- combining, with sliding window / Combining regression with the sliding window

- regression model
- inputs, defining / Defining the inputs, parameters, and other variables
- variables / Defining the inputs, parameters, and other variables
- parameters / Defining the inputs, parameters, and other variables
- defining / Defining the model
- loss function, defining / Defining the loss function
- training / Training the model

- regularization
- about / Overfitting, Regularization
- Ridge regularization / Ridge
- Lasso regularization / Lasso
- ElasticNet / ElasticNet
- early stopping / Early stopping

- regularization models
- Lasso regression / Regularized regression
- Ridge regression / Regularized regression
- ElasticNet regression / Regularized regression
- reference / Regularized regression

- regularized regression / Regularized regression
- reinforcement learning
- about / Reinforcement learning 101
- Q function / Q function (learning to optimize when the model is not available)
- exploration and exploitation / Exploration and exploitation in the RL algorithms
- V function / V function (learning to optimize when the model is available)
- techniques / Reinforcement learning techniques
- Naive Neural Network policy / Naive Neural Network policy for Reinforcement Learning

- Remote Procedure Call (RPC) / Serving the trained model
- representational capacity / Capacity of a model
- reset gate / GRU network
- residual / Defining the loss function
- ResNet / The Microsoft ResNet-50 model
- Retinopathy / Diagnosing medical images
- retrieval pipeline
- about / Building the retrieval pipeline
- building / Building the retrieval pipeline
- bottleneck features, extracting for an image / Extracting bottleneck features for an image
- similarity, computing between query image and target database / Computing similarity between query image and target database

- Ridge regularization / Ridge, Ridge regularization
- Rubner-Tavan's network
- about / Rubner-Tavan's network
- example / Example of Rubner-Tavan's network

## S

- saddle points / Loss and cost functions
- same padding / Strides and padding
- Sanger's network
- about / Sanger's network
- example / Example of Sanger's network

- satellite images
- segmenting / Segmenting satellite images
- FCN, modeling for segmentation / Modeling FCN for segmentation

- saver class
- used, for saving graph variables / Saving and restoring all graph variables with the saver class
- used, for restoring selected variables / Saving and restoring selected variables with the saver class
- used, for saving selected variables / Saving and restoring selected variables with the saver class

- scale-space concept / The scale-space concept
- scale space / Localizing objects using sliding windows
- Scikit-Fuzzy
- reference link / Example of fuzzy C-means with Scikit-Fuzzy

- Scikit-Learn
- label propagation / Label propagation in Scikit-Learn

- segmenting instances / Segmenting instances
- SegNet / The SegNet architecture
- SegNet architecture
- about / The SegNet architecture
- layers, upsampling by pooling / Upsampling the layers by pooling
- layers, sampling by convolution / Sampling the layers by convolution
- connections, skipping for training / Skipping connections for better training

- selected variables
- restoring, with saver class / Saving and restoring selected variables with the saver class
- saving, with saver class / Saving and restoring selected variables with the saver class

- Selective search / Regions of the convolutional neural network (R-CNN)
- Self-Organizing Maps (SOMs)
- about / Self-organizing maps
- example / Example of SOM

- semantic segmentation
- about / Predicting pixels
- algorithms / Algorithms for semantic segmentation
- Fully Convolutional Network (FCN) / The Fully Convolutional Network
- SegNet architecture / The SegNet architecture
- dilated convolution / Dilated convolutions
- DeepLab / DeepLab
- RefiNet / RefiNet
- PSPnet / PSPnet
- large kernel matters / Large kernel matters
- DeepLab v3 / DeepLab v3

- semi-supervised model
- scenario / Semi-supervised scenario
- transductive learning / Transductive learning
- inductive learning / Inductive learning
- assumptions / Semi-supervised assumptions

- semi-supervised Support Vector Machines (S3VM)
- about / Semi-supervised Support Vector Machines (S3VM)
- example / Example of S3VM

- separable convolution / Separable convolution
- seq2seq models / RNN variants
- Sequential Least Squares Programming (SLSQP) / Example of S3VM
- servables / TensorFlow Serving
- server class
- used, for restoring graph variables / Saving and restoring all graph variables with the saver class

- shattering /
- Shi-Malik spectral clustering algorithm / Spectral clustering
- Siamese network
- about / Siamese networks
- contrastive loss / Contrastive loss

- Sigmoid / The perceptron
- sigmoid / Sigmoid
- silhouette score / Silhouette score
- similarity learning
- algorithms / Algorithms for similarity learning
- Siamese network / Siamese networks
- FaceNet / FaceNet
- DeepNet model / The DeepNet model
- DeepRank / DeepRank
- visual recommendation systems / Visual recommendation systems

- simple CNN
- benchmarking / Benchmarking with simple CNN

- simple Recurrent Neural Network (RNN)
- about / Simple Recurrent Neural Network

- Single shot multi-box detector / Single shot multi-box detector
- singular value decomposition (SVD) / Zero-centering and whitening, Principal Component Analysis
- sliding window / Localizing objects using sliding windows
- softmax / Softmax
- softmax function / Models and data
- software packages
- installing / Installing software packages
- Python / Python
- Open Computer Vision (OpenCV) / Open Computer Vision - OpenCV
- TensorFlow library / The TensorFlow library
- Keras library / The Keras library

- sparse coding / Lasso
- spatial invariance / Spatial transformer networks
- spatial transformer networks / Spatial transformer networks
- spectral clustering / Spectral clustering
- spectral clustering, with Scikit-Learn
- SqueezeNet model / The SqueezeNet model
- stacked autoencoder
- about / Autoencoder types
- in TensorFlow / Stacked autoencoder in TensorFlow
- using / Stacked autoencoder in TensorFlow
- in Keras / Stacked autoencoder in Keras

- Standard K-Fold / Cross-validation
- stochastic gradient descent (SGD) / Mean squared error, Gradient descent, Stochastic gradient descent
- Stochastic Gradient Descent (SGD) / The AlexNet model
- strategies, distributed execution
- model parallel / Strategies for distributed execution
- data parallel / Strategies for distributed execution

- Stratified K-Fold / Cross-validation
- strided convolution / Sampling the layers by convolution
- Support Vector Machine (SVM) / Cross-validation, Semi-supervised Support Vector Machines (S3VM), Brand safety
- Synchronous Update / Strategies for distributed execution

## T

- t-Distributed Stochastic Neighbor Embedding (t-SNE)
- about / t-SNE
- example / Example of t-distributed stochastic neighbor embedding

- TensorFlow
- Recurrent Neural Networks (RNNs) / TensorFlow for RNN
- stacked autoencoder / Stacked autoencoder in TensorFlow
- autoencoder, denoising / Denoising autoencoder in TensorFlow
- variational autoencoder / Variational autoencoder in TensorFlow
- models, restoring / Saving and Restoring models in TensorFlow
- models, saving / Saving and Restoring models in TensorFlow
- using, in Deep Convolutional GAN / Deep Convolutional GAN with TensorFlow and Keras

- TensorFlow clusters
- about / TensorFlow clusters
- specification, defining / Defining cluster specification
- server instances, creating / Create the server instances
- graph, defining for asynchronous updates / Define and train the graph for asynchronous updates
- graph, training for asynchronous updates / Define and train the graph for asynchronous updates
- graph, defining for synchronous updates / Define and train the graph for synchronous updates
- graph, training for synchronous updates / Define and train the graph for synchronous updates

- TensorFlow debugger (tfdbg)
- used, for debugging / Debugging with the TensorFlow debugger (tfdbg)
- reference / Debugging with the TensorFlow debugger (tfdbg)

- TensorFlow library
- about / The TensorFlow library
- installing / Installing TensorFlow
- example, to print Hello / TensorFlow example to print Hello, TensorFlow
- example, for adding two numbers / TensorFlow example for adding two numbers
- TensorBoard / TensorBoard
- TensorFlow serving tool / The TensorFlow Serving tool

- TensorFlow playground
- playing / Playing with TensorFlow playground
- reference link / Playing with TensorFlow playground

- TensorFlow RNN cell classes / TensorFlow RNN Cell Classes
- BasicRNNCell / TensorFlow RNN Cell Classes
- BasicLSTMCell / TensorFlow RNN Cell Classes
- LSTMCell / TensorFlow RNN Cell Classes
- GRUCell / TensorFlow RNN Cell Classes
- MultiRNNCell / TensorFlow RNN Cell Classes
- LSTMBlockCell / TensorFlow RNN Cell Classes
- LSTMBlockFusedCell / TensorFlow RNN Cell Classes
- GLSTMCell / TensorFlow RNN Cell Classes
- GridLSTMCell / TensorFlow RNN Cell Classes
- GRUBlockCell / TensorFlow RNN Cell Classes
- NASCell / TensorFlow RNN Cell Classes
- UGRNNCell / TensorFlow RNN Cell Classes

- TensorFlow RNN cell wrapper classes / TensorFlow RNN Cell Wrapper Classes
- TensorFlow RNN model construction classes / TensorFlow RNN Model Construction Classes
- TensorFlow Serving (TFS)
- about / TensorFlow Serving
- installing / Installing TF Serving
- models, saving / Saving models for TF Serving
- models, serving / Serving models with TF Serving
- in Docker containers / TF Serving in the Docker containers
- Docker image, building / Building a Docker image for TF serving
- Kubernetes / TensorFlow Serving on Kubernetes

- TensorFlow serving tool
- reference link / The TensorFlow Serving tool

- tensor values
- fetching, with tf.Session.run() function / Fetching tensor values with tf.Session.run()
- printing, with tf.Print() function / Printing tensor values with tf.Print()

- tf.Assert() function
- used, for asserting on conditions / Asserting on conditions with tf.Assert()

- tf.Print() function
- used, for printing tensor values / Printing tensor values with tf.Print()

- tf.Session.run() function
- used, for fetching tensor values / Fetching tensor values with tf.Session.run()

- Tikhonov regularization / Ridge
- time series datasets
- conversion, reference / MLP for time series regression

- trained model
- serving / Serving the trained model

- trained regression model
- training set / Training and validation sets
- transductive learning / Transductive learning
- Transductive Support Vector Machines (TSVM)
- about / Transductive Support Vector Machines (TSVM)
- example / Example of TSVM

- transfer learning / Transfer learning
- transition probability / A gentle introduction to Markov chains
- transpose convolution / Transpose convolution
- transposed convolution / Sampling the layers by convolution
- triplet loss / FaceNet, Triplet loss
- truncated backpropagation through time (TBPTT) / Backpropagation through time (BPTT)

## U

- ultra-nerve segmentation / Ultra-nerve segmentation
- unbiased estimator / Bias of an estimator
- underfitting / Underfitting
- up-convolution / Sampling the layers by convolution
- update gate / GRU network

## V

- validation set / Training and validation sets
- valid padding / Strides and padding
- Vapnik-Chervonenkis-capacity /
- Vapnik-Chervonenkis theory /
- variational autoencoder
- in TensorFlow / Variational autoencoder in TensorFlow
- about / Variational autoencoder in TensorFlow
- in Keras / Variational autoencoder in Keras

- VC-capacity /
- VC-dimension /
- VGG-16 model / The VGG-16 model
- VGGFace2 dataset
- reference link / The VGGFace2 dataset

- visual features
- about / Understanding visual features
- nearest neighbor / Understanding visual features
- dimensionality reduction / Understanding visual features
- maximal patches / Understanding visual features
- occlusion / Understanding visual features
- deep learning models, activation visualizing / Visualizing activation of deep learning models
- DeepDream / The DeepDream
- adversarial examples / Adversarial examples

- Visual Geometry Group (VGG) / The VGG-16 model, Fine-tuning several layers in deep learning
- visualization
- embedding / Embedding visualization
- guided backpropagation / Guided backpropagation

- Viterbi algorithm / Viterbi algorithm

## W

- weighted log-likelihood / Weighted log-likelihood
- weight shrinkage / Ridge
- weight vector
- stabilization / Weight vector stabilization and Oja's rule

- whitening
- about / Zero-centering and whitening
- advantages / Zero-centering and whitening

- wider face / Face detection
- winner-takes-all / Self-organizing maps

## Y

- YOLO object detection algorithm / The YOLO object detection algorithm
- You look only once (YOLO) / The YOLO object detection algorithm

## Z

- zero-centering / Zero-centering and whitening