Learning Computer Vision Week 9

Hello everyone, sorry about not posting for the past couple weeks—I’ve been on vacation in South Korea with my family. It was really cool seeing how much more futuristic it felt in Seoul (not really, it’s just a much cleaner city than American cities). Hopefully, society can keep progressing with the help of researching in AI more!

Monday, November 4th (Part 6: Training the Model)

Today, I looked at the same IBM lab for making an object detection CNN model with the help of a pre-trained model (if you want to catch up on the previous parts, see my past weeks’ posts), but now, I can finally analyze the part where the model is being trained.

epochs = 40
start_datetime = datetime.now()
!python -m object_detection.model_main \
    --pipeline_config_path=$DATA_PATH/pipeline.config \
    --num_train_steps=$epochs \
    --num_eval_steps=100

regex = re.compile(r"model\.ckpt-([0-9]+)\.index")
numbers = [int(regex.search(f).group(1)) for f in os.listdir(OUTPUT_PATH) if regex.search(f)]
TRAINED_CHECKPOINT_PREFIX = os.path.join(OUTPUT_PATH, 'model.ckpt-{}'.format(max(numbers)))

!python3 -m object_detection.export_inference_graph \
  --pipeline_config_path=$DATA_PATH/pipeline.config \
  --trained_checkpoint_prefix=$TRAINED_CHECKPOINT_PREFIX \
  --output_directory=$EXPORTED_PATH
end_datetime = datetime.now()

The “datetime” lines

start_datetime = datetime.now()
end_datetime = datetime.now()

Their main purpose is just to record the start and end time of when the model is being trained, so that you can calculate and see how long it takes to train and export the model.

The TensorFlow modules

model_main module section

First, we have the model_main module, one of the more simple modules that TensorFlow has to offer:

!python -m object_detection.model_main \
    --pipeline_config_path=$DATA_PATH/pipeline.config \
    --num_train_steps=$epochs \
    --num_eval_steps=100

Ok, so a lot to unpack here. First of all, I learned that some TensorFlow modules are built to be executed as shell commands (bash, powershell, etc.), and this is one of them. But somehow, these modules are in a python file!? Well, this code snippet was from an IBM lab that used Jupyter Notebook, and in Jupyter Notebooks, an exclamation mark “!” at the beginning of the line allows me to execute shell commands directly from a notebook cell.

With that out of the way, the “model_main” module acts similarly to how a native function would, being accessible with a single command. Its primary function is to train a model using the configuration file it was given, along with being able to do additional functions such as saving checkpoints during training, and evaluating the model and logging evaluation metrics.

# Syntax
python -m object_detection.model_main \
    --pipeline_config_path=<path_to_pipeline_config> \
    --model_dir=<path_to_model_directory> \
    --num_train_steps=<number_of_training_steps> \
    --num_eval_steps=<number_of_evaluation_steps> \
    --alsologtostderr

This is also where the .config file we spent so much time on last week comes into play; in the first variable, we see the .config file’s path ($DATA_PATH/pipeline.config) being assigned to the --pipline_config_path option, which will give the model settings that the module needs in order to set up the training process.

export_inference_graph model section

Second is the export_inference_graph module: it’s not as straightforward as the model_main module, but basically the primary function of the export_inference_graph module is to convert the trained model into a deployable format: a process called model exporting or graph exporting. Think of a trained model as a completed 3D print; it has to go though post-processing, which for the model includes steps like “freezing” model parameters and placeholders and getting rid of unnecessary data specific to training and backpropagation, like dropout layers, and overall optimizes the model for its specific-use case: that’s that the this section with the export_inference_graph module does.

# Syntax
python -m object_detection.export_inference_graph \
    --pipeline_config_path=<path_to_pipeline_config> \
    --trained_checkpoint_prefix=<path_to_checkpoint> \
    --output_directory=<output_directory>

The regex section

This is the snippet section that I’m talking about:

regex = re.compile(r"model\.ckpt-([0-9]+)\.index")
numbers = [int(regex.search(f).group(1)) for f in os.listdir(OUTPUT_PATH) if regex.search(f)]
TRAINED_CHECKPOINT_PREFIX = os.path.join(OUTPUT_PATH, 'model.ckpt-{}'.format(max(numbers)))

A quick rundown about regexes for those who don’t know what it is: “regex” stands for “regular expression”, and it’s a powerful tool in programming if you want to be able to do things like edit complex strings (e.g. file paths) or extract data from a complex for mat such as an email; these type of tasks require complex pattern searching. A regex come in the form of a sequence of characters (like a string), where it defines a search pattern.

In this case, the data that we are trying to extract from the files in the OUTPUT_PATH directory are the checkpoint numbers for each filename, which we save to the numbers array though a list comprehension. How do I know this?

This is the regex in the snippet:

# in python, all regexes begin with an "r" followed by the regex in a string format, as shown.
r"model\.ckpt-([0-9]+)\.index"
# An example of a filename that would fit this regex format:
"model.ckpt-101.index"

• model\.ckpt-: This part of the pattern looks for text that starts with "model.ckpt-". The backslash (\) before the dot escapes it, so it’s treated as a literal dot rather than a wildcard character (wildcards are placeholders that can take any value).

• ([0-9]+): This part matches one or more digits (any number from 0 to 9) and captures them as a group. The parentheses around [0-9]+ create a capturing group, which allows you to extract the matched digits.

• \.index: This part looks for the literal text ".index" at the end of the string.

Putting the regex into context,

numbers = [int(regex.search(f).group(1)) for f in os.listdir(OUTPUT_PATH) if regex.search(f)]

The list comprehension for the numbers array basically says “for each file f in the directory OUTPUT_PATH, search for filenames f that matches the regex format, then save the digits that were captured in the first capturing group: ([0-9]+) of that filename into the list as an integer.”

Resources

Course I followed: