For this project, we will be using data from the Waymo Open dataset. The files can be downloaded directly from the website as tar files or from the Google Cloud Bucket as individual tf records.
The data in the classroom workspace will be organized as follows:
/data/waymo/
- contains the tf records in the Tf Object detection api format.
/home/workspace/data/
- test: contain the test data (empty to start)
- train: contain the train data (empty to start)
- val: contain the val data (empty to start)
The experiments folder will be organized as follow:
experiments/
- exporter_main_v2.py: to create an inference model
- model_main_tf2.py: to launch training
- experiment0/....
- experiment1/....
- experiment2/...
- pretrained-models/: contains the checkpoints of the pretrained models.
For local setup if you have your own Nvidia GPU, you can use the provided Dockerfile and requirements in the build directory.
Follow the README therein to create a docker container and install all prerequisites.
In the classroom workspace, every library and package should already be installed in your environment. You will not need to make use of gcloud to download the images.
Note: This first step is already done for you in the classroom workspace. You can find the downloaded and processed files within the /data/waymo/ directory (note that this is different than the /home/workspace/data you'll use for splitting )
The first goal of this project is to download the data from the Waymo's Google Cloud bucket to your local machine. For this project, we only need a subset of the data provided (for example, we do not need to use the Lidar data). Therefore, we are going to download and trim immediately each file. In download_process.py, you can view the create_tf_example function, which will perform this processing. This function takes the components of a Waymo Tf record and saves them in the Tf Object Detection api format. An example of such function is described here. We are already providing the label_map.pbtxt file.
You can run the script using the following (you will need to add your desired directory names):
python download_process.py --data_dir {processed_file_location} --temp_dir {temp_dir_for_raw_files}
You are downloading 100 files so be patient! Once the script is done, you can look inside your data_dir folder to see if the files have been downloaded and processed correctly.
Now that you have downloaded and processed the data, you should explore the dataset! This is the most important task of any machine learning project. To do so, open the Exploratory Data Analysis notebook. In this notebook, your first task will be to implement a display_instances function to display images and annotations using matplotlib. This should be very similar to the function you created during the course. Once you are done, feel free to spend more time exploring the data and report your findings. Report anything relevant about the dataset in the writeup.
Keep in mind that you should refer to this analysis to create the different spits (training, testing and validation).
Now you have become one with the data! Congratulations! How will you use this knowledge to create the different splits: training, validation and testing. There are no single answer to this question but you will need to justify your choice in your submission. You will need to implement the split_data function in the create_splits.py file. Once you have implemented this function, run it using:
python create_splits.py --data_dir /home/workspace/data/
NOTE: Keep in mind that your storage is limited. The files should be moved and not copied.
Now you are ready for training. As we explain during the course, the Tf Object Detection API relies on config files. The config that we will use for this project is pipeline.config, which is the config for a SSD Resnet 50 640x640 model. You can learn more about the Single Shot Detector here.
First, let's download the pretrained model and move it to training/pretrained-models/.
Now we need to edit the config files to change the location of the training and validation files, as well as the location of the label_map file, pretrained weights. We also need to adjust the batch size. To do so, run the following:
python edit_config.py --train_dir /home/workspace/data/train/ --eval_dir /home/workspace/data/val/ --batch_size 4 --checkpoint ./training/pretrained-models/ssd_resnet50_v1_fpn_640x640_coco17_tpu-8/checkpoint/ckpt-0 --label_map label_map.pbtxt
A new config file has been created, pipeline_new.config.
You will now launch your very first experiment with the Tensorflow object detection API. Create a folder training/reference. Move the pipeline_new.config to this folder. You will now have to launch two processes:
- a training process:
python model_main_tf2.py --model_dir=training/reference/ --pipeline_config_path=training/reference/pipeline_new.config
- an evaluation process:
python model_main_tf2.py --model_dir=training/reference/ --pipeline_config_path=training/reference/pipeline_new.config --checkpoint_dir=training/reference/
NOTE: both processes will display some Tensorflow warnings.
To monitor the training, you can launch a tensorboard instance by running tensorboard --logdir=training. You will report your findings in the writeup.
Most likely, this initial experiment did not yield optimal results. However, you can make multiple changes to the config file to improve this model. One obvious change consists in improving the data augmentation strategy. The preprocessor.proto file contains the different data augmentation method available in the Tf Object Detection API. To help you visualize these augmentations, we are providing a notebook: Explore augmentations.ipynb. Using this notebook, try different data augmentation combinations and select the one you think is optimal for our dataset. Justify your choices in the writeup.
Keep in mind that the following are also available:
- experiment with the optimizer: type of optimizer, learning rate, scheduler etc
- experiment with the architecture. The Tf Object Detection API model zoo offers many architectures. Keep in mind that the
pipeline.configfile is unique for each architecture and you will have to edit it.
Modify the arguments of the following function to adjust it to your models:
python .\exporter_main_v2.py --input_type image_tensor --pipeline_config_path training/experiment0/pipeline.config --trained_checkpoint_dir training/experiment0/ckpt-50 --output_directory training/experiment0/exported_model/
Finally, you can create a video of your model's inferences for any tf record file. To do so, run the following command (modify it to your files):
python inference_video.py -labelmap_path label_map.pbtxt --model_path training/experiment0/exported_model/saved_model --tf_record_path /home/workspace/data/test/tf.record --config_path training/experiment0/pipeline_new.config --output_path animation.mp4
This section should contain a brief description of the project and what we are trying to achieve. Why is object detection such an important component of self driving car systems?
This section should contain a brief description of the steps to follow to run the code for this repository.
This section should contain a quantitative and qualitative description of the dataset. It should include images, charts and other visualizations.
This section should detail the cross validation strategy and justify your approach.
This section should detail the results of the reference experiment. It should includes training metrics and a detailed explanation of the algorithm's performances.
This section should highlight the different strategies you adopted to improve your model. It should contain relevant figures and details of your findings.