Academic Databases
Explore Our Semantic Databases
STEM & Tech
Math, Physics, CS & Engineering...
Economics
Macro, Micro, Econometrics...
Business
Management, Marketing, Finance...
Health & Life Sciences
Biology, Medicine, Neuroscience...
Humanities & Social Sciences
Psychology, Law, Philosophy, History...
General Studies
General & interdisciplinary studies...
Explore Topics
Features

Deep Learning Image Classification Tutorial for Beginners (TensorFlow GPU)

Added: 2026-08-07

Deep Dive

Basic proficiency in Python programming, including familiarity with data manipulation libraries like NumPy.

ปูพื้นฐานการใช้ Python ร่วมกับ NumPy | สำหรับงาน Data Science [FULL COURSE]

ปูพื้นฐานการใช้ Python ร่วมกับ NumPy | สำหรับงาน Data Science [FULL COURSE]

101K

NumPy is a fundamental Python library for mathematical calculations and data management in scientific computing, statistics, and engineering. It provides efficient array operations that are essential for data science workflows. The library enables fast numerical computations that would be slow with standard Python lists. Understanding NumPy is crucial for anyone working with data analysis, machine learning, or scientific computing in Python.

Click to watch →

[TUTORIAL] PYTHON para Análise de Dados - Aprenda do ZERO

[TUTORIAL] PYTHON para Análise de Dados - Aprenda do ZERO

6.5K

This section introduces NumPy, a fundamental library for numerical computations in Python. NumPy is essential for data analysis and machine learning because it provides efficient array operations. To use NumPy, first import it: import numpy as np (using 'np' as an alias). To create arrays, use np.array([values]). Arrays can have multiple dimensions. NumPy supports element-wise mathematical operations: multiplying an array by a number (array * 2), adding a constant (array + 100), and performing other operations on all elements simultaneously. This makes NumPy much more efficient than regular Python lists for numerical computations.

Click to watch →

Programming In Python|CST 363|KTU S6 CSE|Important Questions|Part 5|#ktu #2019 scheme #python #cse

Programming In Python|CST 363|KTU S6 CSE|Important Questions|Part 5|#ktu #2019 scheme #python #cse

1.4K

This comprehensive section covers three essential Python libraries for data manipulation. The os module provides file system operations: os.getcwd() returns the current working directory, os.makedirs() creates new directories, and os.walk() traverses directory trees to generate file names. Pandas enables structured data analysis: converting dictionaries to DataFrames, using .shape for dimensions, .iloc[] for index-based slicing, and .loc[] for label-based column selection. NumPy handles numerical computing: matrix transpose swaps rows and columns, trace calculates diagonal sums, and identity matrices use np.eye(). These libraries form the foundation of data science and numerical computing in Python.

Click to watch →

Python Interview Questions and Answers | Top Python Interview Questions | Intellipaat

Python Interview Questions and Answers | Top Python Interview Questions | Intellipaat

13.1K

This comprehensive section covers Python programming fundamentals and data analysis. Core concepts include: keywords (reserved words like 'true', 'false', 'not'), literals (strings, numbers, booleans, None), dictionaries (key-value pairs), classes and objects (blueprints and instances), the init method (constructor), and inheritance (child classes acquiring parent properties). Numpy operations include creating arrays (1D, 2D, zero-filled), element-wise addition, finding N largest values using np.argsort(), and array manipulation. Pandas operations include creating DataFrames from lists and dictionaries, filtering with boolean indexing, introducing NaN values, counting NaN values, renaming columns, and transforming elements using map() with lambda functions. Visualization techniques include creating line plots and bar plots with matplotlib. File operations involve opening and reading files. Lambda functions provide concise anonymous function syntax.

Click to watch →

Curso gratuito de Introducción a Python (2/2)

Curso gratuito de Introducción a Python (2/2)

82.2K

This comprehensive Python course covers essential data analysis techniques using NumPy for numerical computing with n-dimensional arrays (ndarray) and Pandas for tabular data manipulation with Series and DataFrames. The curriculum includes array operations, slicing, boolean masking, random number generation, and statistical functions, followed by Pandas structures, indexing methods (loc, iloc), data reading/writing, missing value handling, and visualization with Matplotlib and Plotly for creating static and interactive charts.

Click to watch →

Deep Dive

Fundamental understanding of machine learning concepts, particularly supervised learning and the concept of training vs. testing datasets.

ML 2 : LearnTraining VS Testing Dataset with Examples #machinelearning

ML 2 : LearnTraining VS Testing Dataset with Examples #machinelearning

92.7K

In machine learning, the training dataset contains labeled examples (attributes and class labels) used to teach a model patterns and relationships, while the testing dataset contains unlabeled examples used to evaluate the model's ability to make accurate predictions on new, unseen data; the training phase uses supervised learning with labeled inputs to build the model, and the testing phase assesses model accuracy by comparing predicted outputs against actual labels.

Click to watch →

ML 3: Supervised Learning with Examples | Regression VS Classification

ML 3: Supervised Learning with Examples | Regression VS Classification

76.4K

Supervised learning is a machine learning approach where machines are trained using labeled data, meaning input data comes with corresponding correct output labels. The core concept involves mapping input variables to output variables through this labeled training process. During training, the machine learns features, structure, and characteristics of each data type by associating input features with their correct labels—for example, recognizing that a shape with four equal sides corresponds to a square. The working principle involves dividing datasets into training (75%), testing (25%), and validation sets, then using algorithms like Support Vector Machine or Decision Tree to train the model. After training, the model is tested with new data to verify its ability to make accurate predictions.

Click to watch →

Train, Test, & Validation Sets explained

Train, Test, & Validation Sets explained

217.7K

Machine learning models require three distinct datasets for effective development and evaluation. The training set teaches the model patterns through repeated exposure during epochs, enabling it to learn features for making predictions. The validation set, separate from training data, evaluates model performance during training to detect overfitting—when the model performs excellently on training data but poorly on new data. Finally, the test set, which remains unlabeled, assesses the model's true predictive capability after training completes, simulating real-world deployment where true labels are unknown. This systematic approach ensures models generalize well beyond their training examples.

Click to watch →

3.1: Introduction to Session 3 - What is Machine Learning?

3.1: Introduction to Session 3 - What is Machine Learning?

80.9K

Supervised learning is the most commonly used machine learning approach, where systems learn from labeled training data containing input-output pairs. The process involves three key components: training data (used to teach the system), test data (separate data used to evaluate performance), and unknown data (real-world data the system will encounter). The system is trained by repeatedly feeding training data, comparing predictions to actual targets, and adjusting parameters to reduce errors. After training, the system is tested on test data to ensure it generalizes well. Only after passing tests is the system ready to make predictions on unknown data in the real world.

Click to watch →

Hot Dog or Not Hot Dog – Convolutional Neural Network Course for Beginners

Hot Dog or Not Hot Dog – Convolutional Neural Network Course for Beginners

91.2K

Machine learning is a subdomain of computer science focused on algorithms that enable computers to learn from data without explicit programming. There are three main types: supervised learning (using labeled data with known outputs), unsupervised learning (finding patterns in unlabeled data), and reinforcement learning (learning through rewards and penalties). In supervised learning, inputs (feature vectors) are processed by models to produce predictions that are compared against actual labels, allowing the model to learn and improve over time.

Click to watch →

Deep Dive

Basic knowledge of neural networks, including concepts like layers, weights, activation functions, and loss functions.

PYTHON & Deep learning | Project Making | COMPLETE in 7 - Days

PYTHON & Deep learning | Project Making | COMPLETE in 7 - Days

10.7K

Neural networks always have three layers: Input Layer (where information enters), Hidden Layer (where computation happens), and Output Layer (final result). At least one hidden layer is mandatory. Each neuron has two parts: the summation part (calculates Y = WX + B, where W is weight, X is feature, B is bias) and the function part (activation function). The activation function makes decisions - sigmoid is used for binary classification (returning 0 or 1). Loss function measures error (more loss means less accuracy, inversely proportional), and optimizer minimizes loss during training. The instructor introduces popular deep learning libraries: TensorFlow (Google), Keras (high-level API), PyTorch, and Theano. Understanding loss and optimizer is essential for training effective neural networks.

Click to watch →

06-1: Artificial Neural Networks - Perceptron

06-1: Artificial Neural Networks - Perceptron

3.1K

Neural networks are organized into layers: input layer, hidden layer(s), and output layer. Each layer contains nodes that receive inputs from the previous layer, apply weights and activation functions, and pass results forward. Activation functions control information flow between layers by determining how much information is passed. Common activation functions include sigmoid (output 0-1), hyperbolic tangent (output -1-1), and ReLU (output 0 or input). Non-linear activation functions are essential because linear functions would make neural networks equivalent to simple linear regression, unable to capture complex patterns. The loss function measures prediction error: mean squared error for regression, cross-entropy for classification. The cost function is the average loss across all training examples. The goal of learning is to minimize the cost function by adjusting weights.

Click to watch →

Bank Defaulters using ANN | Architecture of ANN | Great Learning

Bank Defaulters using ANN | Architecture of ANN | Great Learning

1.9K

Neural networks follow a two-step process: forward propagation (input → hidden → output) and backward propagation (error minimization). The architecture consists of input layers receiving raw data, hidden layers processing patterns, and output layers producing predictions. Network depth is measured from the first hidden layer: one hidden layer = two-layer network, two hidden layers = three-layer network. Each neuron receives weighted inputs from all previous layer neurons. Four primary activation functions serve distinct purposes: sigmoid/tanh for binary classification with outputs between 0-1 or -1-1, ReLU for hidden layers with outputs from 0 to infinity, and softmax for multi-class classification ensuring probabilities sum to 1. Loss functions quantify prediction error: Mean Squared Error for regression, Binary Cross-Entropy for binary classification, and Categorical Cross-Entropy for multi-class classification. Backpropagation computes gradients (derivatives of loss w.r.t. each parameter) and adjusts parameters using gradient descent. Weights and biases are initialized randomly to break symmetry. The update rule: new_parameter = old_parameter - learning_rate × (derivative). Learning rate controls step size—large rates risk overshooting minima, small rates ensure stable but slow convergence. Well-behaved loss functions are convex (U-shaped), guaranteeing single global minima.

Click to watch →

NN - 6 - Backpropagation: Compute the Derivatives - Part 1

NN - 6 - Backpropagation: Compute the Derivatives - Part 1

4.1K

A neural network consists of input layers, hidden layers with activation functions, and output layers. In this example, the input has two dimensions (plus a bias term), the first hidden layer has three neurons with sigmoid activation, and the output layer has one neuron with sigmoid activation. The predicted value is denoted as y_hat (a2). Weights are matrices (W1 is 2x3, W2 is 3x1) and biases are row vectors (b1 is 1x3). The linear transformation z = Wx + b produces inputs to activation functions, which produce outputs a (activations). The loss function L measures prediction error.

Click to watch →

An introduction to neural nets using TensorFlow, Keras, and the Titanic Survival data

An introduction to neural nets using TensorFlow, Keras, and the Titanic Survival data

1.9K

Neural networks are built from neurons (perceptrons) that receive input features multiplied by individual weights, sum these weighted values, and pass results through activation functions. Multiple neurons form hidden layers in fully connected architectures. Common activation functions include Linear (unchanged outputs for regression), Sigmoid (0-1 scaling for binary classification probabilities), ReLU (positive values unchanged, negatives zero for non-linear modeling), and Softmax (normalized probability distributions for multi-class classification). Loss functions quantify prediction error: Mean Squared Error calculates squared differences for regression, while Cross-Entropy measures probability distribution differences for classification. Binary Cross-Entropy is used for two-class classification problems.

Click to watch →

Deep Dive

Conceptual understanding of how digital images are represented as numerical data (pixels, RGB channels).

Images, Pixels and RGB

Images, Pixels and RGB

705.8K

Images are represented digitally through pixels, which are tiny dots of light made up of red, green, and blue color channels; each color channel uses 8 bits (ranging from 0 to 255) to represent 256 different intensities, meaning each pixel requires 24 bits (or 3 bytes) of data, and image filters work by applying mathematical functions to modify these RGB values.

Click to watch →

Developing Computer Vision apps with Go - Marian Motagnino

Developing Computer Vision apps with Go - Marian Motagnino

248

At its core, a digital image is fundamentally an array of pixels, where each pixel represents a specific color through numerical values. For color images, this involves RGB (Red, Green, Blue) values that combine to create all visible colors. Black and white images use only two values representing brightness levels. This concept can be understood by thinking about pixelated graphics from old arcade games like Pac-Man, where everything was composed of discrete colored squares. Modern high-resolution images may make this less obvious visually, but the underlying principle remains the same: any image is essentially numerical data that computers can process and analyze.

Click to watch →

SMIT DS batch 8: NumpyClass 1

SMIT DS batch 8: NumpyClass 1

412

Digital images are fundamentally composed of pixels, which are numerical values representing color information. Each pixel contains color values that define its appearance. The RGB (Red, Green, Blue) color model represents colors using three channels, each with values ranging from 0 to 255. The combination of these three values determines the final color. Understanding images as numerical data is essential for image processing and computer vision applications.

Click to watch →

Sesión 6: IA-900

Sesión 6: IA-900

823

Digital images are composed of pixels arranged in a grid. Each pixel is represented by three numerical values (0-255) corresponding to Red, Green, and Blue (RGB) color channels. Black is represented as (0,0,0) and white as (255,255,255). This fundamental representation allows computers to process and display images mathematically.

Click to watch →

Digitalisierung und Programmierung - Codes - Prof. Dr. Nicolas Meseth

Digitalisierung und Programmierung - Codes - Prof. Dr. Nicolas Meseth

145

Digital images are composed of pixels (picture elements) arranged in a grid. Each pixel stores color information using the RGB (Red, Green, Blue) additive color model, where each channel ranges from 0 to 255. This 8-bit per channel system produces 16,777,216 colors (True Color), sufficient for most human visual perception. The RGB model works because screens emit light, and combining different intensities of red, green, and blue creates the full spectrum of colors. This fundamental principle underlies all digital imaging and display technology.

Click to watch →

Image Classification Basics

Task Differences

Setup and Tools

Environment Prep

Image Loading I

Image Loading II

Image Loading III

Model Setup

Image Prediction

Model Comparison

Image Classification Basics

0:00

Playing Section

1
Defines image classification using salient features like dogs and fish.
2
Highlights AlexNet's 2012 win and its impact on deep learning.
3
Mentions famous models like AlexNet, GoogleNet, and MobileNet.

Deep Dive

Advanced transfer learning and fine-tuning techniques to adapt pre-trained models (like MobileNet) to specific, custom datasets.

Fine-Tuning MobileNet on custom data set شرح عربي

Fine-Tuning MobileNet on custom data set شرح عربي

7.1K

Fine-tuning MobileNet involves extracting the pre-trained base model (removing the original 1000-class output layer), adding a custom output layer with softmax activation matching your target classes, freezing the first 23 layers to prevent overfitting on small datasets, and training only the new layers on your custom data while maintaining the pre-trained feature extraction capabilities.

Click to watch →

Teachable Machine 1: Image Classification

Teachable Machine 1: Image Classification

222.5K

Transfer learning leverages pre-trained models to solve new tasks with limited data. MobileNet, trained on ImageNet with millions of images, learns to extract image features efficiently. Instead of training from scratch, we take MobileNet's learned feature extraction capabilities and fine-tune them with our own dataset (25-50 images per category). This approach achieves comparable accuracy to training from scratch with thousands of images. The process involves: loading the pre-trained MobileNet architecture, freezing lower layers that capture general image features, and retraining upper layers on your specific categories. This technique dramatically reduces training time and data requirements while maintaining strong performance.

Click to watch →

Cancer Detection Using Deep Learning | Deep Learning Projects | Deep Learning Training | Edureka

Cancer Detection Using Deep Learning | Deep Learning Projects | Deep Learning Training | Edureka

268.1K

Implementing transfer learning requires Functional API for attaching custom layers to pre-trained models. Steps: import MobileNet with input_shape, include_top=False, and weights='imagenet'; freeze base layers by setting trainable=False; attach Flatten layer to base model output; add Dense layers for classification (Dense(1, activation='sigmoid') for binary classification); compile with optimizer and loss function; train using fit_generator with callbacks. This approach dramatically improves performance on small medical datasets—achieving 93% accuracy versus 83% with custom CNNs—because pre-trained features compensate for limited domain-specific data.

Click to watch →

Clasificación de imágenes usando transferlearning y los modelos Resnet50, VGG19, Mobilenet y VGG16

Clasificación de imágenes usando transferlearning y los modelos Resnet50, VGG19, Mobilenet y VGG16

15.9K

ResNet50 has 23 million parameters with deeper architecture and bifurcations. For transfer learning, the last layer is excluded, new layers with dropout (30% random connection removal) are added, and fine-tuning freezes the first 14 layers, reducing trainable parameters from 36 million to 12 million. VGG19 has 23 million parameters and similar depth. MobileNet is an efficient model with only 3 million parameters, trained from scratch without transfer learning. Despite fewer parameters, it achieves good performance. Evaluation involves training for 50 epochs, generating training/validation loss curves, and computing performance metrics including confusion matrix.

Click to watch →

Transfer learning: Pretrained embedding, fine-tuning, differential learning | Computer Vision Series

Transfer learning: Pretrained embedding, fine-tuning, differential learning | Computer Vision Series

5.1K

This final major section advances beyond basic transfer learning to sophisticated optimization techniques. It demonstrates fine-tuning by unfreezing the pre-trained MobileNetV2 model, achieving 100% training accuracy and 80-87% validation accuracy. The section then introduces exponential decay learning rates, which gradually reduce learning rate over epochs for stable convergence. Finally, differential learning rates are implemented, assigning smaller rates to pre-trained base models (preserving learned features) and larger rates to new classifier heads (enabling rapid adaptation). The instructor shows validation accuracy reaching 86-87% with differential learning. Throughout, the section reinforces that transfer learning is essential for small datasets, with appropriate optimization strategies significantly impacting final performance.

Click to watch →

Deep Dive

Building and optimizing custom data input pipelines using the tf.data API for high-performance training.

Training Performance: A user’s guide to converge faster (TensorFlow Dev Summit 2018)

Training Performance: A user’s guide to converge faster (TensorFlow Dev Summit 2018)

20K

The tf.data API is the recommended approach for TensorFlow data loading. A basic pipeline loads TFRecord files, shuffles, repeats, parses with custom functions, and batches data. Initial implementations often achieve only ~150 images/second on TPUs, far below potential. The systematic optimization methodology involves measuring performance, identifying bottlenecks, optimizing them, and repeating. Key tools include capture_tpu_profile and TensorBoard's Trace Viewer, which reveals whether TPUs are idle waiting for data or actively computing.

Click to watch →

Using the tf.data API to build input pipelines (TensorFlow Meets)

Using the tf.data API to build input pipelines (TensorFlow Meets)

8K

The tf.data API provides a unified, high-performance input pipeline for TensorFlow that combines the flexibility of Python-based data loading with the efficiency of queue-based systems, achieving benchmarks of 13,000 images per second while remaining accessible to developers of all skill levels through convenience functions and a performance guide.

Click to watch →

Inside TensorFlow: tf.data + tf.distribute

Inside TensorFlow: tf.data + tf.distribute

22.8K

The TF data API addresses fundamental challenges in machine learning workflows: large datasets exceeding memory capacity, preprocessing requiring randomization, and CPU-GPU performance gaps. The ETL framework (Extract, Transform, Load) provides structured pipeline construction. Core transformations include dataset constructors, map (with graph tracing for performance), and batch operations. Optimization techniques—software pipelining via prefetch, parallel map with num_parallel_calls, and parallel file reading with interleave—maximize resource utilization. Auto-tuning delegates optimization decisions to the runtime, while the TensorFlow Datasets project provides over 60 pre-built datasets spanning multiple modalities.

Click to watch →

Distributed TensorFlow training (Google I/O '18)

Distributed TensorFlow training (Google I/O '18)

37.7K

Building efficient input pipelines is critical for distributed training performance. The TF Data API provides tools for parallelizing different pipeline phases: (1) Parallel file reading using tf.data.TFRecordDataset with parallel reads, (2) Parallelizing map transformations using num_parallel_calls equal to CPU core count, and (3) Prefetching to decouple data production from consumption. Advanced techniques include fusing shuffle/repeat and map/batch operations to reduce overhead. These techniques enable overlapping CPU preprocessing with GPU training, preventing the input pipeline from becoming a bottleneck when scaling to multiple GPUs.

Click to watch →

Performant, scalable models in TensorFlow 2 with tf.data, tf.function & tf.distribute (TF World '19)

Performant, scalable models in TensorFlow 2 with tf.data, tf.function & tf.distribute (TF World '19)

9.4K

This comprehensive section covers the complete journey from understanding TensorFlow training fundamentals to implementing high-performance data pipelines. It begins with the custom training loop structure: model definition (MobileNetV2), loss function (sigmoid cross-entropy with logits), optimizer (Adam), gradient tape for automatic differentiation, and mini-batch iteration. The data pipeline components are analyzed: shuffling, disk loading, augmentation (resizing, flipping, noise), and batching, with each stage stressing different system resources (I/O, CPU, memory). A naive Python generator implementation reveals critical bottlenecks: under 100 images/second throughput and GPU utilization below 20% due to stalls between training steps. The solution is TF Data, an ETL framework (Extract, Transform, Load) that reads data from storage, transforms it using TensorFlow ops in C++ runtime, and prepares it for accelerator consumption. Key optimizations include software pipelining via prefetch, parallelizing transformation and extraction stages, and auto-tuning parameters. This eliminates stalls and provides over 2x throughput improvement.

Click to watch →

Deep Dive

Exploring more complex Convolutional Neural Network (CNN) architectures, such as ResNet, EfficientNet, or Vision Transformers (ViTs).

ConvNets

ConvNets

1.5K

ResNet addresses the vanishing gradient problem that prevents training very deep networks. ResNet learns residual functions f(x) = h(x) - x rather than desired functions h(x) directly, with output constructed as f(x) + x. This makes it easier to learn identity functions and enables training of 152-layer networks achieving state-of-the-art performance. ResNet uses residual connections with 3x3 filters, and for deeper networks, bottleneck layers improve efficiency with 1x1 convolutions. Vision Transformers (ViT) represent a different paradigm applying transformer principles to images. ConvNeXt combines CNN principles with ViT lessons. MobileNet is designed for mobile devices with only 9 million parameters, trading some accuracy for efficiency.

Click to watch →

Praktisi Mengajar Pengolahan Citra Digital Part 1: Introduction to Convolutional Neural Network

Praktisi Mengajar Pengolahan Citra Digital Part 1: Introduction to Convolutional Neural Network

104

This section covers advanced CNN architectures that address key challenges. ResNet (Residual Network) addresses the vanishing gradient problem in deep networks by introducing skip connections that allow gradients to flow directly through the network, enabling training of very deep architectures. EfficientNet improves computational efficiency by using depthwise separable convolution, which decomposes standard convolution into depthwise convolution (one filter per input channel) followed by pointwise convolution (1x1 convolution), reducing parameters and computation while maintaining accuracy. These architectures represent significant advances in CNN design for practical applications.

Click to watch →

Vision Transformer (ViT) - An image is worth 16x16 words | Paper Explained

Vision Transformer (ViT) - An image is worth 16x16 words | Paper Explained

46.2K

The Vision Transformer (ViT) applies the transformer architecture from natural language processing to computer vision by dividing images into fixed-size patches (e.g., 16x16 pixels), flattening them into vectors, applying linear projection to embed them into the model's dimension space, adding positional encodings to preserve spatial information, and feeding them into transformer layers with multi-head attention followed by multi-layer perceptrons for classification; unlike CNNs which have inherent inductive biases for local receptive fields, ViT learns these biases from data, making it particularly effective in the big data regime where it outperforms CNNs like ResNet while requiring less computational resources for training.

Click to watch →

Lecture 9 | CNN Architectures

Lecture 9 | CNN Architectures

466K

This lecture covers the evolution of CNN architectures that achieved state-of-the-art performance on ImageNet classification, including AlexNet (2012) which introduced ReLU and won the first CNN-based competition, VGGNet (2014) which demonstrated that deeper networks with smaller 3x3 filters could achieve better performance, GoogLeNet (2014) which introduced inception modules for computational efficiency with 12x fewer parameters than AlexNet, and ResNet (2015) which revolutionized deep learning by using residual connections to enable training of extremely deep networks (up to 152 layers) by learning residual mappings rather than direct mappings, solving the optimization problem that prevented deeper networks from performing better.

Click to watch →

텐서플로우 2.0 튜토리얼 #7 CNN 쉽게 이해하기

텐서플로우 2.0 튜토리얼 #7 CNN 쉽게 이해하기

2.3K

ResNet introduces skip connections to solve the degradation problem in deep networks, enabling training of hundreds of layers. Variants (18, 34, 50, 101, 152) differ in depth. EfficientNet scales depth, width, and resolution simultaneously using compound scaling, achieving better accuracy with fewer parameters than traditional approaches. Both architectures represent state-of-the-art solutions for image classification, with EfficientNet variants (B0-B7) offering trade-offs between size and performance.

Click to watch →

Deep Dive

Deploying trained image classification models to edge devices or mobile applications using TensorFlow Lite (TFLite).

TensorFlow Lite for Android (Coding TensorFlow)

TensorFlow Lite for Android (Coding TensorFlow)

112.9K

TensorFlow Lite is a lightweight TensorFlow solution for mobile and embedded devices that enables running machine learning models on Android devices with low latency, supporting classification, regression, and other ML tasks without server round trips; it uses pre-trained MobileNet models stored as .tflite files with corresponding label files, loaded via an Interpreter that can leverage Android Neural Networks API for hardware acceleration or default to CPU, with models stored in app assets and processed through camera input to produce label predictions with probability scores.

Click to watch →

237 - What is Tensorflow Lite and how to convert keras model to tflite?

237 - What is Tensorflow Lite and how to convert keras model to tflite?

18.2K

This comprehensive tutorial covers the complete TensorFlow Lite workflow for deploying machine learning models on edge devices. The video begins by explaining why TensorFlow Lite is necessary: deep learning models can be very large (10MB to GBs), making deployment on resource-constrained devices challenging. Edge devices include phones, Raspberry Pi, and embedded systems. The typical workflow involves: (1) training models on desktop/cloud resources, (2) converting models to TensorFlow Lite format, (3) optimizing models during conversion, and (4) deploying to edge devices. The video demonstrates this with a complete malarial parasite detection example, showing how to train a binary classifier, convert it to TensorFlow Lite, and perform inference. Model optimization reduces size significantly (from ~9.3MB to ~1.16MB) while maintaining prediction quality. The video compares three approaches: Keras model, TensorFlow Lite without optimization, and TensorFlow Lite with optimization, demonstrating that edge deployment is feasible while maintaining accuracy.

Click to watch →

TensorFlow Lite (TF Dev Summit ‘19)

TensorFlow Lite (TF Dev Summit ‘19)

28.2K

TensorFlow Lite is Google's infrastructure framework for deploying machine learning models on resource-constrained edge devices such as mobile phones, wearables, and microcontrollers, addressing the growing need to run ML closer to data sources for improved privacy, lower latency, and reduced bandwidth usage; the framework achieves efficient deployment through conversion tools, hardware delegates (CPU, GPU, DSP), optimization techniques like post-training quantization and connection pruning, and now extends support to microcontrollers with as little as 20KB model footprint and 30KB RAM requirements, enabling applications like always-on voice recognition and real-time image classification on battery-powered embedded systems.

Click to watch →

Machine Learning Zero to Hero (Google I/O'19)

Machine Learning Zero to Hero (Google I/O'19)

1.8M

TensorFlow Lite enables running machine learning models on mobile devices, embedded systems, and edge devices like Raspberry Pi and Edge TPUs. The TF Lite converter takes the standard SavedModel and optimizes it for resource-constrained environments, dramatically reducing model size while maintaining functionality. This allows on-device inference without internet connectivity or server dependencies, enabling applications like real-time camera analysis directly on phones or IoT devices.

Click to watch →

TensorFlow Lite for Edge Devices - Tutorial

TensorFlow Lite for Edge Devices - Tutorial

101.6K

TensorFlow Lite is an open-source framework that enables efficient deployment of machine learning models on edge devices by converting standard TensorFlow/Keras models into optimized flat buffer format, achieving significant size reduction (from ~1.2MB to ~100KB) without compromising accuracy through techniques like quantization and model optimization.

Click to watch →

Deep Dive

Transitioning from image classification to advanced computer vision tasks like Object Detection, Image Segmentation, and Keypoint Detection.

COMPLETE DETECTRON2 TUTORIAL | Instance Segmentation, Object Detection, Keypoints Detection and more

COMPLETE DETECTRON2 TUTORIAL | Instance Segmentation, Object Detection, Keypoints Detection and more

74K

Detectron2 is Facebook AI's open-source framework built on PyTorch that enables efficient implementation of multiple computer vision tasks including object detection, instance segmentation, semantic segmentation, panoptic segmentation, and keypoint detection through a unified API, allowing users to switch between different models by specifying the task type and automatically downloading pre-trained weights from the model zoo.

Click to watch →

Introducing the Object Detection Task, CoCo dataset and mAP metric

Introducing the Object Detection Task, CoCo dataset and mAP metric

4.6K

Computer vision evolved from simple image classification (identifying what object exists) to object detection (identifying what object exists AND where it is located). Object localization predicts bounding box coordinates (X, Y, height, width) using mean squared error loss instead of cross-entropy. This evolution enabled keypoint detection applications like facial landmark prediction (Snapchat filters) and human pose estimation for sports analysis. The progression demonstrates how adding spatial awareness transforms models from recognizing objects to understanding their positions and relationships within scenes.

Click to watch →

09.06 Detection and Segmentation

09.06 Detection and Segmentation

315

This comprehensive section traces the evolution of computer vision tasks from basic image classification to complex object detection. Image classification serves as the foundation, using deep convolutional architectures with convolutional and pooling layers followed by fully connected layers to classify entire images. Semantic segmentation extends this by classifying each pixel into semantic categories, requiring dense prediction across the entire image. Fully Convolutional Networks (FCNs) enable this by preserving spatial dimensions through convolutional layers without fully connected layers. The encoder-decoder architecture addresses computational inefficiency by using downsampling and upsampling stages. Object detection combines classification and localization, requiring networks to identify objects and their precise locations using bounding boxes. Detection methods are categorized into two-stage detectors (RCNN, Fast RCNN, Faster RCNN) that generate region proposals then classify them, and single-stage detectors (YOLO, SSD) that predict all detections simultaneously.

Click to watch →

Image classification vs Object detection vs Image Segmentation | Deep Learning Tutorial 28

Image classification vs Object detection vs Image Segmentation | Deep Learning Tutorial 28

182.6K

In computer vision, image classification assigns a single label to an entire image (e.g., 'dog'), object detection identifies multiple objects within an image using bounding boxes (e.g., detecting both a cat and dog), and image segmentation classifies each pixel into specific categories (e.g., labeling all red pixels as 'dog' and yellow pixels as 'cat'). These three tasks represent progressively more detailed approaches to analyzing visual content, with segmentation being the most granular as it specifies the exact location and boundaries of each object at the pixel level.

Click to watch →

YOLO11 Tutorial on Object Detection, Segmentation, Pose Estimation & Image Classification

YOLO11 Tutorial on Object Detection, Segmentation, Pose Estimation & Image Classification

18K

This extensive section explores YOLO 11's capabilities beyond basic object detection. It covers image segmentation, which requires manual model download and produces pixel-level object region identification; pose estimation, which detects human keypoints for skeleton overlays and requires specific person-class inputs; and image classification, which predicts object categories from ImageNet 1000 classes. The section also introduces oriented bounding boxes (OBB) for rotated object detection, trained on DOTA V1's 15 classes. Each task requires understanding model requirements, manual download procedures, and appropriate input selection to achieve optimal results.

Click to watch →

Image Classification Basics

Task Differences

Setup and Tools

Environment Prep

Image Loading I

Image Loading II

Image Loading III

Model Setup

Image Prediction

Model Comparison

Image Classification Basics

0:00

Playing Section

1
Defines image classification using salient features like dogs and fish.
2
Highlights AlexNet's 2012 win and its impact on deep learning.
3
Mentions famous models like AlexNet, GoogleNet, and MobileNet.

170K views3.2K42:36@deeplearning_by_phdscholar6925Original Release: 2020-09-21

This tutorial demonstrates how to implement image classification using pre-trained deep learning models in Python with TensorFlow. The process involves loading images using four methods (IPython.display, TensorFlow/Keras API, OpenCV, and PIL/Pillow), then using pre-trained architectures like MobileNet v1 and v2 to classify images. The workflow includes resizing images to 224x224 pixels, converting them to NumPy arrays, expanding dimensions for batch input, and applying model-specific preprocessing. Finally, predictions are decoded into human-readable labels using utility functions, allowing users to classify any image by simply providing it to the pre-trained model without needing to train the network from scratch.

[00:00:00]hello everyone i'm shawn allah i'm a phd student at enhan university south korea my major is computer vision and deep learning uh and today in this video we will be covering image recognition and classification algorithm uh based on deep learning architectures how deep learning architectures resolve this image recognition and classification problem so in this regard we will be using python and in python we will be using the deep learning library which is tensorflow so before diving into actual um coding it's better that we should have some brainstorming so what is image classification and recognition so based on saline feature for example this is a dog image sorry this is a dog image right so we do have a grass and some background as well but the most salient feature in this image is obvious obviously it's a dog right and similarly the most promising and most salient feature in this image is a fish and in this image it is a dog and in this image it's elephant obviously so if we provide this image to a deep learning architecture it will definitely classify this image as a dock and in this image as a fish this image as a dog and this image as an elephant but how to do it so uh let's get back to some history so in 2012 alex net uh beat the in uh image classification challenge in 2012 um alex not beat the human capacity right so and that in this regard uh deep learning architecture has become really famous and uh since then we are using and we are checking uh i mean we are really surprising day by day by the deep learning architectures they are performing very well all right so we have some famous uh deep learning algorithms for image classification such as alex nut google not and mobile nut and mobile and is also by google and the tensorflow is also by google so uh okay so a mobile land is uh i guess in 2017 it was the first version and now it has three versions in 2008 it has second version 2 and in 2019 it has third version as well so we will be using mobile net and other algorithms as well for this particular problem such as image classification or recognition and in this regard we will be using the imagenet data set which was the part of a challenge right so but again uh i mean we can start now uh the coding of the image classification but you might have heard a lot of other words similar to image classification or recognition such as object detection so for example in this why we need object detection for example so what is the how to classify this image because the both of them are salient feature right so it's unfair if we classify this image as a cat or a dog right so because both of the candidates have sail same sealant feature right so in this regard we can solve this problem using object detection so object detection actually the background is based on classification as well but in this object detection we also localize the image as well such as in this picture or image the dog is also localized and we have covered some boundary and we have shown that this is the dog at this location right so similarly the caron dog is separated like this and this is a real world problem uh of m i mean for example uh it's a traffic it can be traffic signal camera as well in this regard we all know that what's happening over here and every object possibly is has been classified and multiple objects have been detected right and the in this regard we will be using two algorithms right like mobilenet and with ssd as well single shot multiple multi-box detector but this is not the main topic of our this presentation if you want to learn more about how to implement object detection you can check our other videos about object detection but in this video we will be only covering image recognition but why we are have we have added object detection because you might have heard a lot of these words so that is why the first goal was to clarify that what is the difference between uh image classification and object detection so in the object detection image classification classification is the base and then we added some another feature like localization and then this is how we perform object detection and similarly you might have heard about image segmentation so definitely image segmentation is again uh based on these algorithms but definitely we will in the image segmentation we have to classify each pixel right rather than object we have to further classify each pixel uh this is semantic segmentation as well so we have instant segmentation and some semantic segmentation these are some typical example of image segmentation so now that we are clarified that what is the difference between image segmentation object detection and image classification our today's topic is image recognition or classification so let's dive into the implementation and the ingredients uh for cooking something definitely we need some ingredients so in this regard today's uh we our lecture is about python implementation will be purely based on python and if you're using windows 10 so you're lucky that we have anaconda which is a package of multiple libraries and ids so you can have jupyter notebook spider vs code and others and then later after installing anaconda we can install these libraries such as tensorflow for deep learning implementation numpy for some areas and other calculations uh opencv for image loading and showing your image and similarly for same uh goal like a pip install pillow we can install it and i will show you how to install these things as well okay uh and that ends for the some brainstorming let's dive into the uh implementation so the best thing is that if you want to install anaconda the best thing is just write on a google download anaconda after you write you will have some links and you if you open first link you will have some different uh uh different exe files to download right such as it's based on python the latest 3.8 version as python 2 is almost obsolete so 64-bit and based on your computer specification or your operating system you're using you can just download okay so i have already downloaded and installed this anaconda and it's super simple in windows just next next next as you already uh thanks to windows it's a user friendly thing so user friendly operating system so we can easily install so after installing uh over here you can observe that some of them have launch button and some of them have installed so in this tutorial i will be covering uh the ide i will use is jupyter notebook okay for programming i will use jupyter notebook and i have already installed so for example if you um install anaconda it will not be installed so all you need is to just click install button and it will be installed soon okay so now i assume that you have already installed an account on your computer and then jupyter notebook in your computer so it's always better to manage everything in folder so for example i believe that if you have some uh created your folder just copy the link of the folder so and just go to your search bar and press the anaconda prompt okay before that you open an account navigator for installing things but now you can go to anaconda prompt now that you have opened the anaconda prompt let me zoom it okay now that you have uh already open it so it's better that you copy and sorry i've already opened yeah so you just paste the uh okay you p you can just paste the path but it's better that you write the cd so that we can go to that um location now that we have already entered in that location just write jupiter notebook after you have installed the joker notebook okay so i'm sorry it's my multiple uh window option so it will be automatically open in the um your explorer right so then you can just uh write new and python and then you will have a you will you can open it right so let me separate it for you guys so that we can only uh enjoy it so um after opening it so i assume uh that you have already installed uh all the dependencies but if not let me show you how to do it for example again you can go for anaconda and this time you just right click and run on as administrator right and give that permission to it and just after you install uh i mean after you open as administrator you can just write uh pip install flow okay all you need is to just write pip install tensorflow and just enter it it will be installed okay so and make sure that uh diving into the opening the jupyter notebook you must have the same environment right in my case it's base environment so just uh create an environment first okay so now i assume that you have only installed the tensorflow okay so uh after being installed uh i can write import tensorflow as tf okay so my spelling was wrong i guess so now that i can do like import tensorflow as tf okay so i can just write if you have not installed you right click the anaconda run as administrator and just pip install tensorflow okay so as it's a beginner level um tutorial so that is why i'm explaining everything okay so that you should you guys should be with me okay so after writing this uh let me copy some of the command to save the time okay so you can import uh numpy as on pi np so what i'm doing actually i'm just pressing over here for every command i'm pressing shift plus enter if you shift plus do if you press keep the shift uh keep the shift uh key pressing and uh press shift and enter together so you will be go to next like shift enter like this okay so now that we have imported these two so let's let me have um okay so like file name is equal to image data so actually inside my and where i'm working it's the image data folder and i have multiple images over here okay as i have multiple uh images i want to for example i want to load this image right so i have name check the name and secondly i have checked the uh what's the extension that's jpg okay so in other case it's uh some of them are jpeg okay so make sure that you have written the correct uh the correct uh format of the image okay so now uh you can just write it so now the file name is only as a string right so now we have not loaded it yet so over here uh as it's a beginner level uh tutorial so i would like to uh teach you or show you some four different methods how to read an image right so definitely before diving like uh presenting this um image to deep learning architecture that and to ask deep learning architecture that what is it is it a dog is that a cat or what type of image it is to classify the image definitely first we need to load it all right so for example before uh loading it uh okay you the the best thing why i like jupiter notebook you can make your notes very uh brilliantly okay it's very good to use uh let me show you for example first as we have four method i will teach you in this video so first method to load an image okay so shifting there but this case i can go to cell and cell type i can change mark down okay and then again shift enter you see this become as a text so you can write all your you can separate your text and your notes this is the best thing about the notebook jupyter notebook okay so first method to load image is using ipython so okay so from ipython it's a uh i hope that if you install jupiter notebook so ipython will be automatically loaded okay so if not then you can just google it and i hope you can find similar command like pip install and you can just execute these commands in the anaconda uh the command window as i showed you before so for example again shift enter i did and now you you see i can just successfully load this image and just i'm just checking that this is the image uh i'm just i just uh displayed okay so uh the the reason why i have the targeted size is 2224 224 is because most of the deep learning uh algorithms are trained on 224 224 uh size okay so by three as well so this is rgb image 224 224 and three okay this was first and second is a good i love the first thing about the jupiter notebook second method to load an image okay and again just you can just go to cell and mark down and then shift and enter second method to load an image okay so what's the second matter so second method i'm going to teach you guys is keras using tensorflow and keras so chaos is basically a tensorflow based api it was before um a few years back it was a separate uh deep learning library uh written in python but keros was so amazing that i guess tensorflow or google bought it and now keras is a part of tensorflow so once you install tensorflow keras will be automatically installed okay so it's the good thing so now you'll be using the keras api to load an image okay that our target size again is 2 2 4 2 4 but in this case over here the second thing is that uh so far although we have uh loaded the image but we have not um showed or displayed it over here in order to display it the best tool uh in the jupyter notebook or any other is just like if you guys are familiar with matlab so in matlab uh we can display images using plot commands so in python we have for plotting the famous uh library is matplotlib okay so if you have not installed just kinda install like i have written the command and you can just follow the instruction and just like previously you have you guys have installed using anaconda command prompt and you can just run this command and hopefully it will be installed in your computer shift enter my plotlib is now installed so plt dot i am show okay so as i have this image so let me copy this image um execute you see i have i achieved two to four and two to four image okay so the best thing about the ipython was in order to display although these images are exactly similar why because the size is two to four into two to four but this looks uh more good why because it is using ipython which is a part of a jupiter notebook as well okay so that is why but don't worry uh as for as far as the deep learning is concerned everything is fine so far so now we have learned two methods uh let's um start our third model learning thermal third uh third method sorry turn method to load an image okay okay knock down and this is third meta method to load an image and the third method over here i'm teaching you guys is um i'm learning as well okay so it's best rather that you learn and teach together so okay so uh the opencv is uh the c plus base or c based uh um you can say image processing kind of library initially it was only with the provided for c plus plus and c but now but not now but since uh many years uh it is now also available in python as well so now uh you can just install pip install opencv python and it will be all automatically installed and then after being installed you can just import it using import cv2 command okay it's super simple okay once uh that i think it's the most uh most uh famously used uh for image processing like loading image image resizing and other things other tasks okay so i can just uh see right like cb2 dot i am read file name file name is already you see if you can notice over here file name is already there right uh in over here i should have also not written but anyhow it's okay so over here i'm using file name and now i have read the image but uh if i over here plt dot i am sure like this i am gg if i do like this you can see over here this image is not as the colors there are something terribly wrong in the colors right so the colors are different and second thing you can notice that the size is different why because we have not targeted any size rather than two to four to four we have just targeted the original size but the problem in this is it's not rgb actually it's gbr okay so uh in order to execu in order to do it best i think the best thing is that let's change the size okay and let's execute the command again so the size is still uh it's changed but uh the color uh is still uh not changed right so in order to change the color uh the command is we used as i told you that it's bgr so it's better to convert it into rgb right so this is the command now you can see the color combination of this and this image is almost same okay so uh now we have learned three methods one is from one is using ipython uh second is tensorflow keras third method is cv2 like opencv and let's learn our last method okay fourth method to load an image okay so although this is not a part of the image recognition but definitely you can choose any of the four so while i was covering one of the method so i thought i should inform you guys about all of the methods so it's better whatever you like so you can go for it okay so it's the kind of learning things right so it's better that we learn and we should know about different methods okay fourth method to load an image okay so what is it what is what is it okay so the fourth method is python uh uh library which is p i l p i l is uh python imaging library so for small things you know the best one among this so far is actually opencv in opencv you can do a lot of things right but um as long as only as long as only loading an image and resizing it and small kind of filtering is concerned you can use any of the four but if you want to dive into real image processing definitely opencv is the best but uh this is also a good method and why i'm uh i mean teaching you all these things because sometimes in the embedded system i'm using the xavier and the other embedded systems sorry for the out of topic thing but sometimes you don't have all of the installations available in your computer or hardware system or embedded system so you can go for any pre-installed thing so it's better so i think most of the time pill is the most like light one and it is very easily installed with a python so sometime it's already installed but if it's not then pip install pillow is the command okay so again uh we can just do it like this okay again just like open cv while the loading the time at loading time we don't specify the target image size and then later we can just like open cv we can resize it but you can see over here while we're performing opencv we said cv2.resize and over here we said i am the image name dot resize into two to four into two to four and now we can just execute the command okay so now we have so now we have learned four different methods uh for loading an image now that we have loaded image still it's a raw image before that it was in hard disk now it's in your ram it's uploaded uh as a as a as a variable right now we have image in our variable but uh it's not um we haven't done anything with it okay so let's uh load uh the the deep learning model okay again i will write like this hash and space and cell and so type and mark down and like this it's really bad that you can make your notes and you can save it and later you can check you don't need to execute right so this is best best when i check later when i open it everything will be same okay so this is best you can track record your previous history and that everything is around okay it was running in a good way okay so for deep learning model definitely as i told you in the start that sorry for moving fast so i loaded this import tensorflow sdf already okay so let me define some for example mobile okay it's my variable name and i will say that tm dot keras okay dot it when i say and when i type tab uh when i press tab it will be automatic completed then mobile as i told you mobile net is the famous one so in 2017 mobile net one was the most lightest one then in 2018 it was mobile net 2 and 19 it was mobile version 3. so we have three versions but unfortunately version 3 is not actually very easily available version 1 and 2 is obviously available so what is mobile and those guys those who don't know about mobile net mobile ad is a deep learning architecture for image classification so the good thing about tensorflow keras api is that the deep learning architecture are already being trained so all of the weights and the weights of the networks is already uh pre-trained and they are set all you need is to just deploy it okay so uh the deep as long as the deep learning is concerned uh first initially definitely we have to teach a deep learning architecture that what is cat what is dog right so in this video as it's a beginner level video we are not performing any kind of training rather we are using a pre-trained uh deep learning architecture okay so thanks to keras uh and tensorflow api uh keras api that it's already available okay so let me select mobile nut and then dot mobile again mobile net and then call it like this okay so uh i have already executed this command actually so that is why it's it's just executed but in in your case when you will be doing it will be start downloading it okay because in the in the fresh start you will not have uh mobile and these weights already trained mobile net uh model is not trained in your computer so in this regard first when you execute the command if it do not exist it will automatically download don't worry all you need is to just execute this command okay so now that we have a model so simple now we have a variable such as mobile is a variable in which we have all the weights of the mobile net version one that's really good okay this is a deep learning model weights or architecture already gets pre-trained okay we have pretend okay now as we have a pretend uh architecture already so now uh okay so we have uh actually we have four faces four phases again in the deep learning so the first phase is actually training okay but not training i would say creating a model okay actually uh if we don't use a pretender or then it's creating a model then after creating a model training a model okay when we have to train it and then after training we have to test or validate it okay okay and test and after test and validation that everything is fine the final stage is predict okay in the prediction what's the difference difference between test and predict is in the test case we also provide labels okay label means uh before the train uh while we are training definitely in the training part we teach the deep learning that this is cat this is dog so in the supervised learning we have to teach that it's uh for example it's a cat or dog or what is it okay so in the predict the best thing about predict is you can download any type of image from internet as long as it is two by two to four and two to four you can just predict your classification algorithm okay you can just check it you don't need any label let ah let's ask the deep learning architecture that what is it okay so the best thing is about predict so as this image do not belong to the imagenet dataset i have downloaded this from an inter from internet okay so you can download any image okay that's the beauty of the prediction so in this regard we will be doing prediction okay okay let's start the prediction okay for prediction oh my god for before prediction we have to do pre-processing of the pre-processing of the image okay we cannot just pass this two to four directly into the deep learning article okay so i think uh it's better to change it into our notes okay now that we have to change into notes so pre-processing what kind of pre-processing we have to do no so let me uh copy the best method again so actually uh i'm using this okay okay you have to verify which one it is actually it's a tensorflow one right uh this one i'm using it again okay like from tensorflow channels pre-processing image and aiming okay so let me copy again these commands and then paste it again over here okay so let's execute it this now uh till that point at this point we already checked and let me check the image is is it uh like uh like a plt dot i am kind of show okay so we do have image so we have displayed and now let's perform some uh pre-processing okay so there are actually technically three kind of image uh i mean there's some pre-processing okay so actually uh as you can see over here if i check okay actually this is a resized image okay resize image it's converted to array so let me check the resized image dot shape okay so you see two to four two to four into three so actually rgb is our three channel right so we have three channel uh red green and blue rgb channels and each has two to four two to four dimension but for deep learning architecture we need the fourth dimension as well so that is why we are using numpy array as i told you that i did let's go back i did numpy as np already so now i'm doing it using it for my like a final image is equal to nb dot expand dims i'm extend expanding them if i check the shape of this image you see i have one more extra dimension okay so after having one more extra dimension we need to pre-process this image like final image here or keras application mobile and pre-process input okay so now i i think our pre-processing already finished but almost finished not the completed one uh we need some utils okay why we need utils uh okay i i think we should cover this utils thing after it okay so oh okay sorry this is mobile okay so for example this was our variable mobile which we just in this we have deep learning weights of the mobile net okay for image classification so for example i can perform on this final image my prediction okay so this prediction is already performed but now uh if we check uh if we check print predictions so it has a lot of things stuff like that we don't know about it okay so it's a huge stuff and we actually don't know what is it okay because we did not uh uh provide them what are the labels okay uh move it okay so as we have not provided him the labels so the best thing uh to check whether your answer is okay or not so again we are using some utility such as from tensorflow.com application import image net utils okay so now if we you can work your this predictions into decoding decode production now if you print your results okay so these are your uh results okay so now this it can let me plt dot show ah i'm sure is img i guess yes this is img okay let me check my image again okay so this was our image okay so it has five or a top actually it has five top predictions right so uh and based on the some confidence level like uh it's a forty percent confident uh the probability is 40 percent confident that there's a street car it in it okay and it has police fan okay and third it's a garbage truck obviously not and we have a mini bus maybe it's saying mini boss and a cab obviously we do have a cap okay but this was all it was based on the mobile net version one which is 2017 algorithm and it was more lightweight but its accuracy was 70 percent so it's better that we use 70 not this it's better that we use another algorithm okay so um okay let me copy on the okay over here let me add the this is the beauty of the jupiter notebook okay mobile let me give it same uh keras oh sorry keras dot applications dot mobile in this case now i can choose mobile and version 2 okay dot mobile version 2 and now we can do like this okay now my mobile version is changed it's now become mobile version two which is more accurate than mobile and version one okay so now uh let me uh i should not remove these lines and i should predict again okay let me predict again okay and i have performed prediction again and let me check my results again oh and i should print my results again let's just copy and paste okay you see this now it's uh in the top a minibus street car ambulance okay now it has predicted the ambulance okay now we are going some good and you see the traffic light as well and a cab as well so now we have a very good thing although this algorithm is basically designed only for one object as i showed you in the in the in the beginning like as first simple image cat and dog but the good thing about it it can give you five top five uh uh possibilities okay or top five peaks okay um i'm not going into the deeper uh deep concepts because if it's for beginners definitely you guys might not understand what what our peak of the algorithms okay so you can say that five top predictions that can be minibus it can be street car ambulance traffic light and cap okay so you see that it's a more mobile and version two is more accurate and the best thing about this architecture our architecture is that you can use over here the best thing about the chaos is that you can use any of them okay where is our loading part over here just let me click okay so i can have for example uh let me annie anyone anyone is equal to tr dot caros sorry cameras dot appley applications dot now that i press tab there are a lot of options like dense net inception okay mobile and version 2 and nas net and a lot of them resonate vgg net so you can try any of them okay and it's super simple you can try the keras thanks to karas api that it has provided us many of the algorithms already available in the market and it's pre-trained and you can perform your prediction on any image you can just download your image from the internet and you can just load this image uh by using my method that i taught you in this lecture and you can use any of them and gen and you can get your predictions that's the best thing and then you can display it as well and you can perform a lot of other uh activities you can just perform okay so any it was a complex you see this was a complex object but if you give if you provided a cat or a dog or a very simple image it's really easy for example okay for you guys i'm doing it again so let's change the okay let's let me change this side uh the image okay okay i think this was the one okay so let me change the file name ah that's okay i will write the file name again that's okay with my file name okay let me write it over here no no no no no or let me write it over here okay that's a good thing not over here okay this was my image name file name is equal to here and that's here so i might think it's better to copy the command okay this is the this was the one and now make sure that you do you give it the actual dimension ah where is it this one okay let me copy it over here and thus let me copy it over here but actually it is gpeg okay if you can see like these images are jpeg file and it was a jpg file okay so make sure that you are providing them uh the actual one okay ah it's amy file name file name okay like this let's it's very super simple uh shift enter shifter now it's uh it's a different thing right it's a different object so let me perform all of these steps again again and again shift enter shift enter super simple shift enter that's all so when i perform shift enter you can see that this is point ninety five percent accord that is caught in this hand but if i change algorithm let me change the algorithm again for example this was version one let me execute this command shift enter now we have mobile and version one which is less accurate than version two okay guys so let's predict only because our input image is not changed all we have changed is only algorithm right if you perform a prediction again you can just check over here it was some different let me print again okay separately so that we can just check the difference you see this mobile learner this is mobile net version one oh mobile not version one of 2017 actually and this is mobile net version 2 of 2018 actually okay so latest one latest one is version 3 but it's not available in the chaos although you can download your the trained architecture from their website but uh it's not available in the keras tensor tensorflow version too so you see over here which one is less accurate the data right is a bit confusing and the first peak is hen or the second peak is called so the but the the exact answer is this one okay so it's 95 percent accurate that it's a okay uh another one is and some other animals like that will sure i don't know what is it okay so the best thing is you have to decide which version you're using so the more simple image the best results you will get but if you have complex images a like like like i have just like this so you can have different images uh okay thank you so much this is all for image recognition part the implementation of the image recognition in the tensorflow if you want to learn about object detection and image segmentation and other deep learning tools and programming it and first we i think we will start from brainstorming as i'm a pg scholar so i'm performing my phd so definitely i will try my best to put all of my effort what i'm learning so i'm a student as well right so i'm learning as well and i'm trying to teach as well so it's the good uh technique to teach others whatever you learn so okay thank you so much for this and stay tuned and please keep watching the videos in my channel thank you so much soon as if you

Up Next

YOLOv8 Object Detection: Train on a Custom Dataset

@Roboflow

491.1K views•2023-01-10

IFS Therapy Demonstration: Complete Session with Unburdening

@IFSCA

95.9K views•2021-01-13

FastAPI vs Flask vs Django: Choosing the Right Python Web Framework

@TechWithTim

302.5K views•2024-05-26

Game of Thrones Opening Credits: A Cinematic Analysis

@gameofthrones

46.3M views•2011-04-18

Related Study Plans & Knowledge Roadmaps

Structured learning paths in General & Interdisciplinary Studies

Browse General & Interdisciplinary Study Plans

general-studies

Containerization: Evolution, Logistics & Trade

01Ancient Trade & Bulk Cargo: Amphorae to Barrels

02The Industrial Revolution & Cardboard Packaging

03The Containerization Revolution: Malcom McLean

+ 2 more learning modules

Explore Roadmap

general-studies

Textile Tech: Evolution, Labor & Global Impact

01Pre-Industrial Textiles: Handloom & Cottage Industry

02Mechanization: The Spinning Jenny to the Power Loom

03The Factory System & Global Labor Transformation

+ 2 more learning modules

Explore Roadmap

general-studies

Pharmacology: Botany, Patents & Biopiracy

01Foundations of Ethnobotany & Traditional Medicine

02The Birth of Synthetic Chemistry: Aspirin & Penicillin

03The Battle Against Malaria: Quinine to Artemisinin

+ 3 more learning modules

Explore Roadmap

general-studies

Writing Surfaces: Papyrus, Parchment & Paper

01Ancient Foundations: Clay, Stone, and Egyptian Papyrus

02Parchment, Vellum, and the Rise of the Codex

03The Chinese Rag Paper Revolution and the Silk Road

+ 3 more learning modules

Explore Roadmap