Learning Computer Vision Week 7

I actually want to make a comprehensive CV model soon, and this week, I’ll be planning to clean up some concepts with CV so that I can finally, hopefully, make my own model (possibly with some images that I have taken).

Tuesday, October 22nd (Part One: Pre-Trained CV Model Setup)

Today I stumbled across some code that supposedly was making an object detection CNN using TensorFlow, and it looked like very strange code, where it seemed cryptic to me, even though it was all in Python; it’s just the sheer amount of different libraries and modules that were being used all at once that was making me all confused. For example, this is some code for preprocessing training and annotated images by assigning them a number. I would later realize that the code that was shown to me was a guide to training a DL Neural Network model using transfer learning, which is essentially finding a pre-trained model which has been trained on a relatively large dataset and is related to your task (e.g. image classification), and tuning it until it works best for your situation. The pre-trained model that I was using is called MobileNet V1.

os.makedirs(DATA_PATH, exist_ok=True)
with open(LABEL_MAP_PATH, 'w') as f:
    for idx, label in enumerate(labels):
        f.write('item {\n')
        f.write("\tname: '{}'\n".format(label))
        f.write('\tid: {}\n'.format(idx + 1))
        f.write('}\n')

os.makedirs(_string path, _char exist_ok=False)

The .makedirs() function from Python’s os library make directories, with possible parameters:

path _(required)

A path string or set of bytes representing a file path that the function will attempt to make a directory (folder) in.

exist_ok _(optional)

The default value of this parameter is False, and if left False, then the program will throw and OSError if the target directory/folder already exists, and in contrast, the program won’t do so if the value for this parameter is True.

open(_string path, _char mode)

The open() function enables the program to read files, write files, create files, and more within running a Python file.

path _(required)

Same parameter as seen before.

mode _(required)

This parameter will be a char, depending on what you want the program to do to the file. The most common chars/modes used for this functions is “r” for reading a file, “w” for writing a file, “a” for appending to a file, and “x” to create a file. For reading and creating, it’s worth noting that the program will throw an error if the file does not exist.

Wednesday, October 23nd (Part Two: Pre-Trained Model Importing)

I continued to analyze the same object detection CNN program from yesterday, and figured out some more of the functions’ functions. This following code retrieves and extracts the pre-trained model from the internet, using the tarfile module/library.

MODEL_TYPE = 'ssd_mobilenet_v1_quantized_300x300_coco14_sync_2018_07_18'
CONFIG_TYPE = 'ssd_mobilenet_v1_quantized_300x300_coco14_sync'
download_base = 'http://download.tensorflow.org/models/object_detection/'
model = MODEL_TYPE + '.tar.gz'
tmp = '/resources/checkpoint.tar.gz'

if not (os.path.exists(CHECKPOINT_PATH)):
    opener = urllib.request.URLopener()
    opener.retrieve(download_base + model, tmp)

    # Extract all the `model.ckpt` files.
    with tarfile.open(tmp) as tar:
        for member in tar.getmembers():
            member.name = os.path.basename(member.name)
            if 'model.ckpt' in member.name:
                tar.extract(member, path=CHECKPOINT_PATH)
            if 'pipeline.config' in member.name:
                tar.extract(member, path=CONFIG_PATH)

    os.remove(tmp)

This is the most ugly important part, where the program imports a pre-trained model from TensorFlow’s Model Zoo by using the os and urllib libraries. This this code, the formula for the pre-trained models’ retrieval URLs is as follows:

 download_base + MODEL_TYPE / CONFIG_TYPE + .tar.gz

urllib.request.URLopener()

Kudos if you figured out that this was a class! This class from the urllib library is a class that creates object instances that can use functions like .open(), .close(), and .retrieve() (which we’ll see later) to handle URL requests from the internet.

opener.retrieve(_string url, filename=_string None)

This function from the urllib.request library downloads a file from a URL and saves it to a specified location.

url _(required)

This parameter is the URL to retrieve.

filename _(required)

This parameter specifies where to save the downloaded file.

.getmembers()

Coming from the tarfile module, in the context of the code, the .getmembers() function retrieves a list of the full PATHs for all the files/“members” in the opened .tar.gz file that the function is attached to.

os.path.basename(_string path)

This function is pretty useful, for it returns the last (most specific) folder/directory name in the path parameter that was passed into the function.

.extract(_string member, path=”.”)

The .extract() function does the actual job of extracting a specific member (file or directory) from a file in a tarball format (e.g. .tar, .tar.gz).

member _(required)

The path (in string form) or TarInfo object that represents the file that you want to extract.

path _(optional)

The destination directory where the extracted file or directory would be saved, if unspecified, then the function will save the extracted file to the current working directory.

Thursday, October 24th (Break: Figuring Out the Pipeline)

For those who don’t know, a pipeline is basically a structured workflow that covers the whole process of making and training and tuning a model. Ok, so like I said, the model that I’m experimenting (to clarify, the code excerpts of it are in this newsletter) uses the MobileNet V1 pre-trained model, but it also uses the MobileNet V1 configuration (same name, different purpose: it’s stupid naming, I know) and the SSD MobileNet Architecture.

Resources

Course I followed: