Using Kili Technology to work with YOLO v7
In this tutorial, we will show how to work with Kili and YOLO v7 to produce a SOTA-grade object detection system.
Working with YOLO v7
To be able to train a model using YOLO v7, you have to create a data.yaml file that indicates the image and label data layout and the classes that you want to detect. You also have to organize your data accordingly. Kili CLI will help you bootstrap this step and does not require a project-specific setup.
The YOLO v7 data.yaml file
Here is an example of YOLO v7 data.yaml file from the repository (example: the COCO 2017 dataset).
# COCO 2017 dataset http://cocodataset.org
# download command/URL (optional)
download: bash ./scripts/get_coco.sh
# train and val data as 1) directory: path/images/, 2) file: path/images.txt, or 3) list: [path1/images/, path2/images/]
train: ./coco/train2017.txt # 118287 images
val: ./coco/val2017.txt # 5000 images
test: ./coco/test-dev2017.txt # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794
# number of classes
nc: 80
# class names
names: [ 'person', 'bicycle’, …]
Enter the Kili CLI
Let’s go through the steps of creating a .yaml file so you can use the Kili data to train a YOLO v7 project.
You can integrate the following steps into a kili_to_yolov7.sh file, or play along with this Colab notebook.
Shape the Kili data
Let’s suppose that you have an object detection project in Kili. For example, we loaded these images from the cyclist Kaggle dataset:
Make sure that you set up:
The
KILI_PROJECT_ID
environment variable (the ID of a Kili project that contains your object detection job). You will use this job’s annotations to train a YOLO v7 object detector.The
KILI_API_KEY
environment variable that contains the API key of your Kili account.
Once done, you are ready to go!
First, export the annotations with the following command:
kili project export --project-id $KILI_PROJECT_ID --verbose --output-format
yolo_v7 --output-file your_export.zip
Then unzip the files:
mkdir my_dataset/
unzip -q your_export.zip -d my_dataset/
This will create a dataset folder with the following subfolders:
my_dataset
├── README.kili.txt
├── data.yaml
├── images
└── labels
It is now time to create train, validation, and test datasets that are needed to make yolo_v7 happy, with a random strategy (50% train, 30% val, 20% test). The following command randomly dispatches each asset path into one file among train.txt
, test.txt
, and val.txt
.
find `pwd`/my_dataset/images -name "*.jpg" | awk '{v=rand();if(v<0.5) {print >
"train.txt"} else if (v>0.8) {print > "test.txt"} else {print > "val.txt"}}'
And finally, you can add the dataset files to the data.yaml
file created:
echo "train: /path/to/my_dataset/train.txt" >> /path/to/my_dataset/data.yaml
echo "val: /path/to/my_dataset/val.txt" >> /path/to/my_dataset/data.yaml
echo "test: /path/to/my_dataset/test.txt" >> /path/to/my_dataset/data.yaml
In the end, your data.yaml
should look like this:
names: ['BICYCLE']
train: /path/to/my_dataset/train.txt
val: /path/to/my_dataset/val.txt
test: /path/to/my_dataset/test.txt
Training a YOLO v7 model
To use YOLO v7, you first need to install the YOLO v7 repository following these instructions, and make sure to download the initial model weights with:
wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt
We are now ready to use Yolov7! First, you can run Yolo V7 training using:
python train.py --workers 8 --batch-size 16 --data /path/to/your/data.yaml --img 320 320 --cfg cfg/training/yolov7-tiny.yaml --weights yolov7.pt --name yolov7 --hyp data/hyp.scratch.tiny.yaml
Importing predictions back into Kili
Once done, you can import the predictions back into Kili. This can help you diagnose labeling or model errors or serve as a source of pre-annotations.
First, run the YOLO v7 detection using the model you generated in the previous step:
python detect.py --weights path/to/the/trained/model/best.pt --conf 0.25 --img-size 640 --source /content/my_dataset/labels/ --save-txt --project path/where/to/store/labels
Then import the results into Kili. You need to specify a model name
of your choice to be able to identify the predictions, and the target job
in your original project ontology (here, JOB_0
).
kili project label path/where/to/store/labels/exp/labels/ --project-id $KILI_PROJECT_ID --prediction --model-name my-YOLO-v7 --metadata-file my_dataset/data.yaml --target-job JOB_0 --input-format yolo_v7 --api-key=$KILI_API_KEY
Now you can visualize the predictions in the Kili interface!
Note that you can also specify the project id of another project, provided that it has the same ontology as the original project. This way, you can use the model-generated annotations to bootstrap human annotations. A human annotator must only validate or correct the model’s predictions. If these predictions are accurate enough, the ratio validation/correction will be high, saving you much annotation time.
Using Kili Technology and Yolo v7: Conclusion
With the steps laid out in this tutorial, you can easily export your project data to the YOLO v7 format, train a model with YOLO v7, and import predictions back into Kili. No more headaches trying to diagnose labeling or model errors – with this approach, you can nip them in the bud and save time. Plus, if you're feeling adventurous, you can switch things up and try YOLO v4 or v5 – just remember to change the label format in Kili import and export!