Gain insights into image data processing and CNNs for image classification using TensorFlow. Delve into CNN architectures and their applications, requiring Python and TensorFlow knowledge.

irml.tar.gz

image-rec

If you want to dive into the technology behind computer vision and self driving cars, this is where to start.

In this course you'll learn how to process data from image files and create convolutional neural networks (CNNs) to classify different types of images. After completing this course, you will have a solid understanding of why CNNs work and which CNN architectures to use for different tasks.

The code for this course is built around the TensorFlow framework, one of the premier frameworks for industry machine learning, and the Python pandas library for data analysis. Knowledge of Python and TensorFlow are prerequisites. 

This course was created by AdaptiLab, a company specializing in evaluating, sourcing, and upskilling enterprise machine learning talent. It is built in collaboration with industry machine learning experts from Google, Microsoft, Amazon, and Apple.

Image Recognition with Machine Learning

# Chapter Goals:</h2>
- Iterate through a dataset and extract pixel data using `tf.compat.v1.Session`



# A. Data iteration</h2>

In the previous chapter we set up a next-element tensor using the `get_next` function. The way we actually execute the data extraction is by using the `run` function of `tf.compat.v1.Session`.

Each time we use `sess.run(next_image)`, we are iterating a single step through our dataset. So the first time we use `sess.run(next_image)`, it'll return the first pixel array in <code>dataset</code> (as a NumPy array), and the $i^{th}$ time it'll return the $i^{th}$ pixel array in `dataset`.


it = tf.compat.v1.data.make_one_shot_iterator(dataset)
next_image = it.get_next()
sess = tf.compat.v1.Session()
for i in range(3):
    sess.run(next_image)

We can only call `sess.run(next_image)` for the number of images there are in the dataset before we get an [OutOfRangeError](https://www.tensorflow.org/api_docs/python/tf/errors/OutOfRangeError).


# B. Using data</h2>

Rather than going through the decoding process every time we use a dataset of image files, it is usually better to just decode once and save the NumPy pixel data in a file. This can be done with the [numpy.save](https://docs.scipy.org/doc/numpy/reference/generated/numpy.save.html) function.

The code below shows examples of using `numpy.save`. The file itself is not human-readable, but can be loaded back into a NumPy array with [numpy.load](https://docs.scipy.org/doc/numpy/reference/generated/numpy.load.html).


import numpy as np

arr = np.array([1, 2, 3])
# Saves to 'arr.npy'
np.save('arr.npy', arr)
# Also saves to 'arr.npy'
np.save('arr', arr)
# Loading from that file
arr_copy = np.load('arr.npy')
print(repr(arr_copy))

There are other more efficient ways to store the decoded data. However, for smaller projects that don't use too large of an image dataset, the way of saving NumPy data in a file works fine.


# Time to Code!

In this chapter we'll be completing the `get_image_data` function from the previous chapter.

Since we're going to return a list of all our image pixel data, we want to first initialize this list.

**Set** `image_data_list` equal to an empty list.

We'll put our iteration and execution code within the scope of a `tf.compat.v1.Session`. For more information on `tf.compat.v1.Session` scopes, see the [Machine Learning for Software Engineers](https://www.educative.io/collection/6083138522447872/5629499534213120) course on Educative.

**Create a** `with tf.compat.v1.Session() as sess` code block.

**Inside the scope of `sess`, create a `for` loop that iterates `i` through `range(len(image_paths))`**.

Inside the `for` loop, we'll execute a single data extraction and append the extracted pixel array to the list.

**Set `image_data` equal to `sess.run(next_image)`**.</p>

**Append the resultant `image_data` to `image_data_list`**.</p>

After iterating through the entire dataset, we can return `image_data_list`.

**Outside the scope of `sess`, return `image_data_list`**.

import tensorflow as tf

# Get the decoded image data from the input image file paths
def get_image_data(image_paths, image_type=None, resize_shape=None, channels=0):
    dataset = get_dataset(image_paths, image_type, resize_shape, channels)
    iterator =tf.compat.v1.data.make_one_shot_iterator(dataset)
    next_image = iterator.get_next()
    # CODE HERE
    
    

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'

import tensorflow as tf
import numpy as np
from PIL import ImageFilter

tf.compat.v1.disable_eager_execution()

tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)

IMAGE_PATHS = ['./image1.png', './image2.png']
JPEG_IMAGE = './image3.jpg'

def decode_image(filename, image_type, resize_shape, channels=0):
    value =  tf.io.read_file(filename, name=None)
    #value =  tf.read_file(filename, name=None)
    if image_type == 'png':
        decoded_image = tf.io.image.decode_png(value, channels=channels)
        #decoded_image = tf.image.decode_png(value, channels=channels)
    elif image_type == 'jpeg':
        decoded_image = tf.io.image.decode_jpeg(value, channels=channels)
        #decoded_image = tf.image.decode_jpeg(value, channels=channels)
    else:
        decoded_image = tf.io.decode_image(value, channels=channels)
        #decoded_image = tf.decode_image(value, channels=channels)
    if resize_shape is not None and image_type in ['png', 'jpeg']:
        decoded_image = tf.image.resize_images(decoded_image, resize_shape)
    #print(decoded_image)
    return decoded_image


def get_dataset(image_paths, image_type, resize_shape, channels):
    filename_tensor = tf.constant(image_paths)
    dataset = tf.data.Dataset.from_tensor_slices(filename_tensor)
    
    def _map_fn(filename):
        return decode_image(filename, image_type, resize_shape, channels=channels)
    
    #print(dataset.map(_map_fn))
    return dataset.map(_map_fn)

def ref_get_image_data(image_paths, image_type=None, resize_shape=None, channels=0):
    dataset = get_dataset(image_paths, image_type, resize_shape, channels)
    #iterator = dataset.make_one_shot_iterator()
    iterator =tf.compat.v1.data.make_one_shot_iterator(dataset)
    next_image = iterator.get_next()
    image_data_list = []
    with tf.compat.v1.Session() as sess:
    #with tf.Session() as sess:
        for i in range(len(image_paths)):
            image_data = sess.run(next_image)
            image_data_list.append(image_data)
    return image_data_list

# Get the decoded image data from the input image file paths
def get_image_data(image_paths, image_type=None, resize_shape=None, channels=0):
    dataset = get_dataset(image_paths, image_type, resize_shape, channels)
    iterator =tf.compat.v1.data.make_one_shot_iterator(dataset)
    next_image = iterator.get_next()
    # CODE HERE
    image_data_list = []
    with tf.compat.v1.Session() as sess:
        for i in range(len(image_paths)):
            image_data = sess.run(next_image)
            image_data_list.append(image_data)
    return image_data_list

Learn how to execute data extraction in TensorFlow.

What you'll learn from this course

Image Processing

CNN

SqueezeNet

ResNet

Execution

Chapter Goals:

A. Data iteration

B. Using data

Time to Code!