Custom Training with YOLOv7 🔥

Some Important links

• Model Inference🤖
• 🚀Training Yolov7 on Kaggle
• Weight and Biases 🐝
• HuggingFace 🤗 Model Repo

Contact Information

• Name - Owais Ahmad
• Phone - +91-9515884381
• Email - owaiskhan9654@gmail.com
• Portfolio - https://owaiskhan9654.github.io/

Objective

To Showcase custom Object Detection on the Given Dataset to train and Infer the Model using newly launched YoloV7.

Data Acquisition

The goal of this task is to train a model that can localize and classify each instance of Person and Car as accurately as possible.

• Link to the Downloadable Dataset

from IPython.display import Markdown, display

display(Markdown("../input/Car-Person-v2-Roboflow/README.roboflow.txt"))

Custom Training with YOLOv7 🔥

In this Notebook, I have processed the images with RoboFlow because in COCO formatted dataset was having different dimensions of image and Also data set was not splitted into different Format. To train a custom YOLOv7 model we need to recognize the objects in the dataset. To do so I have taken the following steps:

• Export the dataset to YOLOv7
• Train YOLOv7 to recognize the objects in our dataset
• Evaluate our YOLOv7 model's performance
• Run test inference to view performance of YOLOv7 model at work

📦 YOLOv7

https://raw.githubusercontent.com/Owaiskhan9654/Yolo-V7-Custom-Dataset-Train-on-Kaggle/main/car-person-2.PNG" width=800>

Image Credit - jinfagang

Step 1: Install Requirements

!git clone https://github.com/WongKinYiu/yolov7 # Downloading YOLOv7 repository and installing requirements
%cd yolov7
!pip install -qr requirements.txt
!pip install -q roboflow

Downloading YOLOV7 starting checkpoint

!wget "https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt"

import os
import glob
import wandb
import torch
from roboflow import Roboflow
from kaggle_secrets import UserSecretsClient
from IPython.display import Image, clear_output, display # to display images



print(f"Setup complete. Using torch {torch._version_} ({torch.cuda.get_device_properties(0).name if torch.cuda.is_available() else 'CPU'})")

https://camo.githubusercontent.com/dd842f7b0be57140e68b2ab9cb007992acd131c48284eaf6b1aca758bfea358b/68747470733a2f2f692e696d6775722e636f6d2f52557469567a482e706e67">

I will be integrating W&B for visualizations and logging artifacts and comparisons of different models!

YOLOv7-Car-Person-Custom

try:
  user_secrets = UserSecretsClient()
  wandb_api_key = user_secrets.get_secret("wandb_api")
  wandb.login(key=wandb_api_key)
  anonymous = None
except:
  wandb.login(anonymous='must')
  print('To use your W&B account,
Go to Add-ons -> Secrets and provide your W&B access token. Use the Label name as WANDB. 
Get your W&B access token from here: https://wandb.ai/authorize')
  
  
  
wandb.init(project="YOLOvR",name=f"7. YOLOv7-Car-Person-Custom-Run-7")

Step 2: Assemble Our Dataset

https://uploads-ssl.webflow.com/5f6bc60e665f54545a1e52a5/615627e5824c9c6195abfda9_computer-vision-cycle.png" alt="">

In order to train our custom model, we need to assemble a dataset of representative images with bounding box annotations around the objects that we want to detect. And we need our dataset to be in YOLOv7 format.

In Roboflow, We can choose between two paths:

• Convert an existing Coco dataset to YOLOv7 format. In Roboflow it supports over 30 formats object detection formats for conversion.
• Uploading only these raw images and annotate them in Roboflow with Roboflow Annotate.

Version v2 Aug 12, 2022 Looks like this.

https://raw.githubusercontent.com/Owaiskhan9654/Yolo-V7-Custom-Dataset-Train-on-Kaggle/main/Roboflow.PNG" alt="">

user_secrets = UserSecretsClient()
roboflow_api_key = user_secrets.get_secret("roboflow_api")

rf = Roboflow(api_key=roboflow_api_key)
project = rf.workspace("owais-ahmad").project("custom-yolov7-on-kaggle-on-custom-dataset-rakiq")
dataset = project.version(2).download("yolov7")

Step 3: Training Custom pretrained YOLOv7 model

Here, I am able to pass a number of arguments: - img: define input image size - batch: determine

Overview

This dataset contains 8,992 images of Uno cards and 26,976 labeled examples on various textured backgrounds.

This dataset was collected, processed, and released by Roboflow user Adam Crawshaw, released with a modified MIT license: https://firstdonoharm.dev/

https://i.imgur.com/P8jIKjb.jpg" alt="Image example">

Use Cases

Adam used this dataset to create an auto-scoring Uno application:

Getting Started

Fork or download this dataset and follow our How to train state of the art object detector YOLOv4 for more.

Annotation Guide

See here for how to use the CVAT annotation tool.

About Roboflow

Roboflow makes managing, preprocessing, augmenting, and versioning datasets for computer vision seamless. :fa-spacer: Developers reduce 50% of their boilerplate code when using Roboflow's workflow, save training time, and increase model reproducibility. :fa-spacer:

The dataset comprises 16.7k images and 2 annotation files, each in a distinct format. The first file, labeled "Label," contains annotations with the original scale, while the second file, named "yolo_format_labels," contains annotations in YOLO format. The dataset was obtained by employing the OIDv4 toolkit, specifically designed for scraping data from Google Open Images. Notably, this dataset exclusively focuses on face detection.

This dataset offers a highly suitable resource for training deep learning models specifically designed for face detection tasks. The images within the dataset exhibit exceptional quality and have been meticulously annotated with bounding boxes encompassing the facial regions. The annotations are provided in two formats: the original scale, denoting the pixel coordinates of the bounding boxes, and the YOLO format, representing the bounding box coordinates in normalized form.

The dataset was meticulously curated by scraping relevant images from Google Open Images through the use of the OIDv4 toolkit. Only images that are pertinent to face detection tasks have been included in this dataset. Consequently, it serves as an ideal choice for training deep learning models that specifically target face detection tasks.

Custom Multi-Altitude Aerial Vehicles Dataset: Created for publishing results for ICUAS 2023 paper "How High can you Detect? Improved accuracy and efficiency at varying altitudes for Aerial Vehicle Detection", following the abstract of the paper. Abstract—Object detection in aerial images is a challenging task mainly because of two factors, the objects of interest being really small, e.g. people or vehicles, making them indistinguishable from the background; and the features of objects being quite different at various altitudes. Especially, when utilizing Unmanned Aerial Vehicles (UAVs) to capture footage, the need for increased altitude to capture a larger field of view is quite high. In this paper, we investigate how to find the best solution for detecting vehicles in various altitudes, while utilizing a single CNN model. The conditions for choosing the best solution are the following; higher accuracy for most of the altitudes and real-time processing ( > 20 Frames per second (FPS) ) on an Nvidia Jetson Xavier NX embedded device. We collected footage of moving vehicles from altitudes of 50-500 meters with a 50-meter interval, including a roundabout and rooftop objects as noise for high altitude challenges. Then, a YoloV7 model was trained on each dataset of each altitude along with a dataset including all the images from all the altitudes. Finally, by conducting several training and evaluation experiments and image resizes we have chosen the best method of training objects on multiple altitudes to be the mixup dataset with all the altitudes, trained on a higher image size resolution, and then performing the detection using a smaller image resize to reduce the inference performance. The main results The creation of a custom dataset was necessary for altitude evaluation as no other datasets were available. To fulfill the requirements, the footage was captured using a small UAV hovering above a roundabout near the University of Cyprus campus, where several structures and buildings with solar panels and water tanks were visible at varying altitudes. The data were captured during a sunny day, ensuring bright and shadowless images. Images were extracted from the footage, and all data were annotated with a single class labeled as 'Car'. The dataset covered altitudes ranging from 50 to 500 meters with a 50-meter step, and all images were kept at their original high resolution of 3840x2160, presenting challenges for object detection. The data were split into 3 sets for training, validation, and testing, with the number of vehicles increasing as altitude increased, which was expected due to the larger field of view of the camera. Each folder consists of an aerial vehicle dataset captured at the corresponding altitude. For each altitude, the dataset annotations are generated in YOLO, COCO, and VOC formats. The dataset consists of the following images and detection objects: Data Subset Images Cars 50m Train 130 269 50m Test 32 66 50m Valid 33 73 100m Train 246 937 100m Test 61 226 100m Valid 62 250 150m Train 244 1691 150m Test 61 453 150m Valid 61 426 200m Train 246 1753 200m Test 61 445 200m Valid 62 424 250m Train 245 3326 250m Test 61 821 250m Valid 61 823 300m Train 246 6250 300m Test 61 1553 300m Valid 62 1585 350m Train 246 10741 350m Test 61 2591 350m Valid 62 2687 400m Train 245 20072 400m Test 61 4974 400m Valid 61 4924 450m Train 246 31794 450m Test 61 7887 450m Valid 61 7880 500m Train 270 49782 500m Test 67 12426 500m Valid 68 12541 mix_alt Train 2364 126615 mix_alt Test 587 31442 mix_alt Valid 593 31613 It is advised to further enhance the dataset so that random augmentations are probabilistically applied to each image prior to adding it to the batch for training. Specifically, there are a number of possible transformations such as geometric (rotations, translations, horizontal axis mirroring, cropping, and zooming), as well as image manipulations (illumination changes, color shifting, blurring, sharpening, and shadowing).

This database contains 4976 planetary images of boulder fields located on Earth, Mars and Moon. The data was collected during the BOULDERING Marie Skłodowska-Curie Global fellowship between October 2021 and 2024. The data was already splitted into train, validation and test datasets, but feel free to re-organize the labels at your convenience.

For each image, all of the boulder outlines within the image were carefully mapped in QGIS. More information about the labelling procedure can be found in the following manuscript (https://agupubs.onlinelibrary.wiley.com/doi/full/10.1029/2023JE008013). This dataset differs from the previous dataset included along with the manuscript https://zenodo.org/records/8171052, as it contains more mapped images, especially of boulder populations around young impact structures on the Moon (cold spots). In addition, the boulder outlines were also pre-processed so that it can be ingested directly in YOLOv8.

A description of what is what is given in the README.txt file (in addition in how to load the custom datasets in Detectron2 and YOLO). Most of the other files are mostly self-explanatory. Please see previous dataset or manuscript for more information. If you want to have more information about specific lunar and martian planetary images, the IDs of the images are still available in the name of the file. Use this ID to find more information (e.g., M121118602_00875_image.png, ID M121118602 ca be used on https://pilot.wr.usgs.gov/). I will also upload the raw data from which this pre-processed dataset was generated (see https://zenodo.org/records/14250970).

Thanks to this database, you can easily train a Detectron2 Mask R-CNN or YOLO instance segmentation models to automatically detect boulders.

How to cite:

Please refer to the "how to cite" section of the readme file of https://github.com/astroNils/YOLOv8-BeyondEarth.

Structure:

. └── boulder2024/ ├── jupyter-notebooks/ │ └── REGISTERING_BOULDER_DATASET_IN_DETECTRON2.ipynb ├── test/ │ └── images/ │ ├── _image.png │ ├── ... │ └── labels/ │ ├── _image.txt │ ├── ... ├── train/ │ └── images/ │ ├── _image.png │ ├── ... │ └── labels/ │ ├── _image.txt │ ├── ... ├── validation/ │ └── images/ │ ├── _image.png │ ├── ... │ └── labels/ │ ├── _image.txt │ ├── ... ├── detectron2_inst_seg_boulder_dataset.json ├── README.txt ├── yolo_inst_seg_boulder_dataset.yaml

detectron2_inst_seg_boulder_dataset.json

is a json file containing the masks as expected by Detectron2 (see https://detectron2.readthedocs.io/en/latest/tutorials/datasets.html for more information on the format). In order to use this custom dataset, you need to register the dataset before using it in the training. There is an example how to do that in the jupyter-notebooks folder. You need to have detectron2, and all of its depedencies installed.

yolo_inst_seg_boulder_dataset.yaml

can be used as it is, however you need to update the paths in the .yaml file, to the test, train and validation folders. More information about the YOLO format can be found here (https://docs.ultralytics.com/datasets/segment/).

FASDD is a largest and most generalized Flame And Smoke Detection Dataset for object detection tasks, characterized by the utmost complexity in fire scenes, the highest heterogeneity in feature distribution, and the most significant variations in image size and shape. FASDD serves as a benchmark for developing advanced fire detection models, which can be deployed on watchtowers, drones, or satellites in a space-air-ground integrated observation network for collaborative fire warning. This endeavor provides valuable insights for government decision-making and fire rescue operations. FASDD contains fire, smoke, and confusing non-fire/non-smoke images acquired at different distances (near and far), different scenes (indoor and outdoor), different light intensities (day and night), and from various visual sensors (surveillance cameras, UAVs, and satellites). FASDD consists of three sub-datasets, a Computer Vision (CV) dataset (i.e. FASDD_CV), a Unmanned Aerial Vehicle (UAV) dataset (i.e. FASDD_UAV), and an Remote Sensing (RS) dataset (i.e. FASDD_RS). FASDD comprises 122,634 samples, with 70,581 annotated as positive samples and 52,073 labeled as negative samples. There are 113,154 instances of flame objects and 73,072 instances of smoke objects in the entire dataset. FASDD_CV contains 95,314 samples for general computer vision, while FASDD_UAV consists of 25,097 samples captured by UAV, and FASDD_RS comprises 2,223 samples from satellite imagery. FASDD_CV contains 73,297 fire instances and 53,080 smoke instances. The CV dataset exhibits considerable variation in image size, ranging from 78 to 10,600 pixels in width and 68 to 8,858 pixels in height. The aspect ratios of the images also vary significantly, ranging from 1:6.6 to 1:0.18. FASDD_UAV contains 36,308 fire instances and 17,222 smoke instances, with image aspect ratios primarily distributed between 4:3 and 16:9. In FASDD_RS, there are 2,770 smoke instances and 3,549 flame instances. The sizes of remote sensing images are predominantly around 1,000×1,000 pixels.FASDD is provided in three compressed files: FASDD_CV.zip, FASDD_UAV.zip, and FASDD_RS.zip, which correspond to the CV dataset, the UAV dataset, and the RS dataset, respectively. Additionally, there is a FASDD_RS_SWIR. zip folder storing pseudo-color images for detecting flame objects in remote sensing imagery. Each zip file contains two folders: "images" for storing the source data and "annotations" for storing the labels. The "annotations" folder consists of label files in four formats: YOLO, VOC, COCO, and TDML. The dataset is divided randomly into training, validation, and test sets, with a ratio of 1/2, 1/3, and 1/6, respectively, within each label format. In FASDD_CV, FASDD_UAV, and FASDD_RS, images and their corresponding annotation files have been individually sorted starting from 0. The flame and smoke objects in FASDD are given the labels "fire" and "smoke" for the object detection task, respectively. The names of all images and annotation files are prefixed with "Fire", "Smoke", "FireAndSmoke", and "NeitherFireNorSmoke", representing different categories for scene classification tasks.When using this dataset, please cite the following paper. Thank you very much for your support and cooperation：################################################################################使用数据集请引用对应论文，非常感谢您的关注和支持：Wang, M., Yue, P., Jiang, L., Yu, D., Tuo, T., & Li, J. (2025). An open flame and smoke detection dataset for deep learning in remote sensing based fire detection. Geo-spatial Information Science, 28(2), 511-526.################################################################################

Overview:

Football (soccer) player and football (soccer) ball detection dataset from Augmented Startups. * Project Type: Object Detection * Labeled/Annotated with: Bounding boxes

Classes:

• football, player

How to Use:

This is a great starter-dataset for those wanting to test player and/or ball-tracking for football (soccer) games with the Deploy Tab, or the Deployment device and method of their choice.

Images can also be Cloned to another project to continue iterating on the project and model. World Cup, Premier League, La Liga, Major League Soccer (MLS) and/or Champions League computer vision projects, anyone?

Roboflow offers AutoML model training - Roboflow Train, and the ability to import and export up to 30 different annotation formats. Leaving you flexibility to deploy directly with a Roboflow Train model, or use Roboflow to prepare and manage datasets, and train and deploy with the custom model architecture of your choice + https://github.com/roboflow-ai/notebooks.

Tips for Model and Dataset Improvement:

• https://blog.roboflow.com/pip-install-roboflow
• https://help.roboflow.com/implementing-active-learning

Accident-Detection-Model

Accident Detection Model is made using YOLOv8, Google Collab, Python, Roboflow, Deep Learning, OpenCV, Machine Learning, Artificial Intelligence. It can detect an accident on any accident by live camera, image or video provided. This model is trained on a dataset of 3200+ images, These images were annotated on roboflow.

Problem Statement

• Road accidents are a major problem in India, with thousands of people losing their lives and many more suffering serious injuries every year.
• According to the Ministry of Road Transport and Highways, India witnessed around 4.5 lakh road accidents in 2019, which resulted in the deaths of more than 1.5 lakh people.
• The age range that is most severely hit by road accidents is 18 to 45 years old, which accounts for almost 67 percent of all accidental deaths.

Accidents survey

https://user-images.githubusercontent.com/78155393/233774342-287492bb-26c1-4acf-bc2c-9462e97a03ca.png" alt="Survey">

Literature Survey

• Sreyan Ghosh in Mar-2019, The goal is to develop a system using deep learning convolutional neural network that has been trained to identify video frames as accident or non-accident.
• Deeksha Gour Sep-2019, uses computer vision technology, neural networks, deep learning, and various approaches and algorithms to detect objects.

Research Gap

• Lack of real-world data - We trained model for more then 3200 images.
• Large interpretability time and space needed - Using google collab to reduce interpretability time and space required.
• Outdated Versions of previous works - We aer using Latest version of Yolo v8.

Proposed methodology

• We are using Yolov8 to train our custom dataset which has been 3200+ images, collected from different platforms.
• This model after training with 25 iterations and is ready to detect an accident with a significant probability.

Model Set-up

Preparing Custom dataset

• We have collected 1200+ images from different sources like YouTube, Google images, Kaggle.com etc.
• Then we annotated all of them individually on a tool called roboflow.
• During Annotation we marked the images with no accident as NULL and we drew a box on the site of accident on the images having an accident
• Then we divided the data set into train, val, test in the ratio of 8:1:1
• At the final step we downloaded the dataset in yolov8 format.
  #### Using Google Collab
• We are using google colaboratory to code this model because google collab uses gpu which is faster than local environments.
• You can use Jupyter notebooks, which let you blend code, text, and visualisations in a single document, to write and run Python code using Google Colab.
• Users can run individual code cells in Jupyter Notebooks and quickly view the results, which is helpful for experimenting and debugging. Additionally, they enable the development of visualisations that make use of well-known frameworks like Matplotlib, Seaborn, and Plotly.
• In Google collab, First of all we Changed runtime from TPU to GPU.
• We cross checked it by running command ‘!nvidia-smi’
  #### Coding
• First of all, We installed Yolov8 by the command ‘!pip install ultralytics==8.0.20’
• Further we checked about Yolov8 by the command ‘from ultralytics import YOLO from IPython.display import display, Image’
• Then we connected and mounted our google drive account by the code ‘from google.colab import drive drive.mount('/content/drive')’
• Then we ran our main command to run the training process ‘%cd /content/drive/MyDrive/Accident Detection model !yolo task=detect mode=train model=yolov8s.pt data= data.yaml epochs=1 imgsz=640 plots=True’
• After the training we ran command to test and validate our model ‘!yolo task=detect mode=val model=runs/detect/train/weights/best.pt data=data.yaml’ ‘!yolo task=detect mode=predict model=runs/detect/train/weights/best.pt conf=0.25 source=data/test/images’
• Further to get result from any video or image we ran this command ‘!yolo task=detect mode=predict model=runs/detect/train/weights/best.pt source="/content/drive/MyDrive/Accident-Detection-model/data/testing1.jpg/mp4"’
• The results are stored in the runs/detect/predict folder.
  Hence our model is trained, validated and tested to be able to detect accidents on any video or image.

Challenges I ran into

I majorly ran into 3 problems while making this model

• I got difficulty while saving the results in a folder, as yolov8 is latest version so it is still underdevelopment. so i then read some blogs, referred to stackoverflow then i got to know that we need to writ an extra command in new v8 that ''save=true'' This made me save my results in a folder.
• I was facing problem on cvat website because i was not sure what

Underwater Drowning Detection DatasetThis dataset contains 5,613 manually annotated underwater images for drowning detection research, captured in controlled swimming pool environments. It provides a balanced distribution of three behavioral states:Swimming (1,871 images)Struggling (1,871 images)Drowning (1,871 images)All images were collected under real underwater conditions and annotated for object detection tasks using the YOLO format.Key FeaturesHigh-resolution underwater images (640×640 pixels, RGB)YOLO .txt annotations with bounding boxes for three behavior classesBalanced class distribution to minimize model biasData collected ethically with lifeguard supervision and participant consentIncludes realistic challenges such as water distortion and lighting variabilityTechnical DetailsTotal Images: 5,613Training/Validation Split: 4,488 / 1,125Classes: Swimming, Struggling, DrowningFormat: JPEG + YOLO annotation filesResolution: 640×640 pixelsBaseline Performance: YOLOv8n achieved 97.5% mAP@50 on this datasetAnnotation FormatEach image has a corresponding .txt file with annotations in YOLO format, where each line follows this structure: Field Descriptions:class_id: Integer label for the class0 = Swimming1 = Struggling2 = Drowningx_center, y_center: Normalized center coordinates of the bounding box (values between 0.0 and 1.0)width, height: Normalized width and height of the bounding box (values between 0.0 and 1.0)Example Annotation:0 0.509896 0.568519 0.453125 0.581481This line indicates a “Swimming” detection (class_id = 0) with a bounding box centered at 50.99% (horizontal) and 56.85% (vertical) of the image dimensions, covering 45.31% of the width and 58.15% of the height.Dataset Folder Structuredatasets/├── images/│ ├── train/│ │ ├── frame_00001.jpg│ │ └── ...│ └── val/│ ├── frame_04489.jpg│ └── ...│├── labels/│ ├── train/│ │ ├── frame_00001.txt│ │ └── ...│ └── val/│ ├── frame_04489.txt│ └── ...│├── classes.txt├── README.mdUse and ApplicationsThis dataset is designed to support the development and evaluation of real-time AI systems for aquatic safety, including:Drowning detection modelsMulti-class object detection in underwater environmentsResearch in underwater computer vision and human activity recognitionCitationIf you use this dataset, please cite:graphqlCopyEdit@dataset{underwater_drowning_detection_2025, title = {Underwater Drowning Detection Dataset}, author = {Hamad Alzaabi and Saif Alzaabi and Sarah Kohail}, year = {2025}, publisher = {Figshare}, note = {Manually annotated underwater images for drowning detection research}}Please also cite the related publication:mathematicaCopyEdit@inproceedings{Alzaabi2025, author = {Hamad Alzaabi and Saif Alzaabi and Sarah Kohail}, title = {Multi‑Swimmer Drowning Detection Using a Custom Annotated Underwater Dataset and Real‑Time AI}, booktitle = {Proceedings of the International Conference on Image Analysis and Processing (ICIAP)}, year = {2025}}

In Smart Cities, technologies are playing an important role in efficiently managing the rapid growth of the world's industrialization today. The deployment of surveillance cameras has proliferated to improve public safety and security. Many Closed-Circuit Television (CCTV) cameras have been installed to monitor and safeguard public spaces efficiently within the cities. Despite advancements in technology, video and image processing still largely rely on manual observation. This manual analysis is time-consuming, prone to missing critical details, and costly in terms of labor and resources. Nevertheless, monitoring large video feeds for long periods indicates fatigue, demise of focus, and errors, particularly when video surveillance is a necessity.
Road anomaly detection is one of the prominent computer vision issues that researchers have investigated to guarantee public safety. Road anomaly identification is increasingly difficult and complex due to the variety and complexity of abnormalities.
Deep learning algorithms must be efficient but also need a large dataset to train to recognize road anomalies in different environments. We proposed a custom real-world data set containing road anomaly images and videos that are made available to the public and private surveillance systems. Primary data were collected from diverse sites in Pakistan, and the data were gathered by recording videos and capturing images by using mobile and surveillance cameras The dataset encompasses five major categories of road anomaly effects.: vehicle accidents, vehicle fire, fighting, snatching(gunpoint), and potholes that classification modeling while promoting improvement in both scientific research and realistic application. The dataset also encompasses annotations with You Only Look Once (YOLO) based bounding boxes and class label files in text format for every image.
The researchers can utilize data to train and validate their anomaly detection algorithms and models, thus increasing public security and safety. This dataset focuses on natural environment scenes with a detailed examination of safe transportation and impacts on broader environmental knowledge. Data can give to the liable and ethical arrangement of Artificial Intelligence technologies in surveillance security system

About This Dataset

The Roboflow Website Screenshots dataset is a synthetically generated dataset composed of screenshots from over 1000 of the world's top websites. They have been automatically annotated to label the following classes: :fa-spacer: * button - navigation links, tabs, etc. * heading - text that was enclosed in <h1> to <h6> tags. * link - inline, textual <a> tags. * label - text labeling form fields. * text - all other text. * image - <img>, <svg>, or <video> tags, and icons. * iframe - ads and 3rd party content.

Example

This is an example image and annotation from the dataset: https://i.imgur.com/mOG3u3Z.png" alt="WIkipedia Screenshot">

Usage

Annotated screenshots are very useful in Robotic Process Automation. But they can be expensive to label. This dataset would cost over $4000 for humans to label on popular labeling services. We hope this dataset provides a good starting point for your project. Try it with a model from our model library.

Collecting Custom Data

Roboflow is happy to provide a custom screenshots dataset to meet your particular needs. We can crawl public or internal web applications. Just reach out and we'll be happy to provide a quote!

About Roboflow

Roboflow makes managing, preprocessing, augmenting, and versioning datasets for computer vision seamless. :fa-spacer: Developers reduce 50% of their boilerplate code when using Roboflow's workflow, save training time, and increase model reproducibility. :fa-spacer:

Project Overview:

The original goal was to use this model to monitor my rowing workouts and learn more about computer vision. To monitor the workouts, I needed the ability to identify the individual digits on the rowing machine. With the help of Roboflow's computer vision tools, such as assisted labeling, I was able to more quickly prepare, test, deploy and improve my YOLOv5 model. https://i.imgur.com/X1kHoEm.png" alt="Example Annotated Image from the Dataset">

https://i.imgur.com/uKRnFZc.png" alt="Inference on a Test Image using the rfWidget"> * How to Use the rfWidget

Roboflow's Upload API, which is suitable for uploading images, video, and annotations, worked great with a custom app I developed to modify the predictions from the deployed model, and export them in a format that could be uploaded to my workspace on Roboflow. * Uploading Annotations with the Upload API * Uploading Annotations with Roboflow's Python Package

What took me weeks to develop can now be done with the help of a single click utilize Roboflow Train, and the Upload API for Active Learning (dataset and model improvement). https://i.imgur.com/dsMo5VM.png" alt="Training Results - Roboflow FAST Model">

Dataset Classes:

• 1, 2, 3, 4, 5, 6, 7, 8, 9, 90 (class "90" is a stand-in for the digit, zero)

This dataset consits of 841 images. There are images from a different rowing machine and also from this repo. Some scenes are illuminated with sunlight. Others have been cropped to include only the LCD. Digits like 7, 8, and 9 are underrepresented.

For more information:

• A full tutorial for creating and deploying this model with YOLOv5: https://vision.philbrockman.com/

The goal of this project is to create a specialized model for detecting and recognizing specific wild animals, including Elephant, Gorilla, Giraffe, Lion, Tiger, and Zebra. We gathered images of these animals and used the Roboflow annotation tool to manually label each animal class. After annotation, the data was exported in the YOLOv8 format.

Next, we trained a custom YOLOv8 model on this dataset to accurately detect and recognize the selected animal species in images. The project leverages YOLOv8’s object detection capabilities to improve detection accuracy for wildlife monitoring and research purposes.

You can find more details about the project on GitHub by clicking on this link. To view the training logs and metrics on wandb, click here.

🏏 Bowling Analysis & Ball Tracking Project 📌 Project Overview This project focuses on real-time ball and stump detection in cricket videos. The goal is to provide an AI-powered analysis of bowling performance by tracking the ball's speed, trajectory, and movement. The project leverages YOLOv8 for object detection and uses custom datasets to improve accuracy. The final application will be a Flutter-based mobile app, enabling seamless video analysis for bowlers at all levels.

🎯 Class Descriptions The dataset includes 5 key classes for training the YOLOv8 model: Ball - Tracks the cricket ball’s movement. Stumps - Detects all three stumps together. Stump - Detects individual stumps. Person - Identifies players in the video. Bat - Detects the presence of the cricket bat. These annotations are manually labeled using LabelImg and formatted for YOLOv8 training.

📅 Current Status & Timeline ✅ Project Setup & Planning (✅ Completed) ✅ Dataset Collection (✅ Completed) ✅ Data Annotation & Labeling (✅ Completed) ✅ YOLOv8 Model Training (🔄 Testing Different Configurations) 🚀 Final Model Optimization & Evaluation (🔜 Next Step) 📱 Flutter App Development & Integration (🔜 Final Phase)

🔗 External Resources 📺 YouTube Tutorial Followed: YOLOv8 Object Detection Guide 📄 Project Blog Updates: Bowling Analysis Blog 📂 GitHub Repository (To be added) 📖 YOLOv8 Documentation: Ultralytics YOLOv8 Docs 📝 Contribution & Labeling Guidelines

Dataset Standardization: Ensure class labels match across all datasets before training. Annotation Format: Use YOLO format [class_id x_center y_center width height] in .txt files. Merging Datasets: Keep consistent class IDs across multiple datasets to avoid conflicts. Training Best Practices: Train on diverse clips for better model generalization

Contains Images from Call of Duty Modern Warfare & Warzone gameplay and has labels for Enemy and Head.

Originally used to train a Yolov5 model to detect when enemies are in view and used a GIMX adapter with Python to send movement controls to connected PS4. Find the complete code on my Github.

This dataset can be used to train custom Computer Vision models to recognize when enemy players appear and locate them.

Checkout this video of the model running on a Twitch streamer's video (Faze Testy): https://youtu.be/cxFpTIK8aYE

Intelligent Invoice Management System

Project Description:
The Intelligent Invoice Management System is an advanced AI-powered platform designed to revolutionize traditional invoice processing. By automating the extraction, validation, and management of invoice data, this system addresses the inefficiencies, inaccuracies, and high costs associated with manual methods. It enables businesses to streamline operations, reduce human error, and expedite payment cycles.

Problem Statement:
Manual invoice processing involves labor-intensive tasks such as data entry, verification, and reconciliation. These processes are time-consuming, prone to errors, and can result in financial losses and delays. The diversity of invoice formats from various vendors adds complexity, making automation a critical need for efficiency and scalability.

Proposed Solution:
The Intelligent Invoice Management System automates the end-to-end process of invoice handling using AI and machine learning techniques. Core functionalities include:
1. Invoice Generation: Automatically generate PDF invoices in at least four formats, populated with synthetic data.
2. Data Development: Leverage a dataset containing fields such as receipt numbers, company details, sales tax information, and itemized tables to create realistic invoice samples.
3. AI-Powered Labeling: Use Tesseract OCR to extract labeled data from invoice images, and train YOLO for label recognition, ensuring precise identification of fields.
4. Database Integration: Store extracted information in a structured database for seamless retrieval and analysis.
5. Web-Based Information System: Provide a user-friendly platform to upload invoices and retrieve key metrics, such as:
- Total sales within a specified duration.
- Total sales tax paid during a given timeframe.
- Detailed invoice information in tabular form for specific date ranges.

Key Features and Deliverables:
1. Invoice Generation:
- Generate 20,000 invoices using an automated script.
- Include dummy logos, company details, and itemized tables for four items per invoice.

1. Label Definition and Format:

   • Define structured labels (TBLR, CLASS Name, Recognized Text).
   • Provide labels in both XML and JSON formats for seamless integration.

2. OCR and AI Training:

   • Automate labeling using Tesseract OCR for high-accuracy text recognition.
   • Train and test YOLO to detect and classify invoice fields (TBLR and CLASS).

3. Database Management:

   • Store OCR-extracted labels and field data in a database.
   • Enable efficient search and aggregation of invoice data.

4. Web-Based Interface:

   • Build a responsive system for users to upload invoices and retrieve data based on company name or NTN.
   • Display metrics and reports for total sales, tax paid, and invoice details over custom date ranges.

Expected Outcomes: - Reduction in manual effort and operational costs.
- Improved accuracy in invoice processing and financial reporting.
- Enhanced scalability and adaptability for diverse invoice formats.
- Faster turnaround time for invoice-related tasks.

By automating critical aspects of invoice management, this system delivers a robust and intelligent solution to meet the evolving needs of businesses.

Here are a few use cases for this project:

1. Automotive Industry Quality Control: Utilize the autoCenterStack model to streamline the quality control process for automobile manufacturers. The model can verify if all components, including steering-wheels, gear-sticks, door-locks, and other interior elements, are installed correctly and meet design specifications.

2. Custom Interior Design Applications: Enhance car customization apps or websites with the autoCenterStack model by allowing users to virtually mix and match various interior components. Users can create a personalized car design by swapping out or modifying steering wheels, gear sticks, door locks, or other features identified by the model.

3. Virtual Reality Driving Simulators: Improve the realism and accuracy of virtual reality driving simulators by incorporating the autoCenterStack model. The model can identify and classify the various components in the simulated environment, allowing developers to achieve a highly detailed and interactive simulation of car interiors.

4. Driver's Education and Training: Integrate the autoCenterStack model into driver's education and training materials to create an engaging and interactive learning experience. Students can learn about car components more effectively by interacting with labeled car interior elements, aiding retention and understanding of important safety and operational components.

5. Online Marketplaces for Used Cars: Improve the user experience on used car marketplaces by utilizing the autoCenterStack model to generate metadata tags for car interior images. This can help potential buyers find specific car models or interior features through relevant search options, streamlining their decision-making process.