Data Available for the paper: "Identification of herbarium specimen sheet components from high-resolution images using deep learning", by Karen M Thompson, Robert Turnbull, Emily Fitzgerald, Joanne L Birch

These are specific annotations of selected specimen sheet digital images from the MELU collection (Melbourne University Herbarium). MELU collection images are available: https://online.herbarium.unimelb.edu.au/

These annotations for use in a YOLO object detection model.

The format of this file is a .ZIP containing a .TXT for each image annotated. Each .TXT file will have a row for each annotated element. Eg. "4 0.064133 0.414363 0.072186 0.309392" (i) first element is an integer identifying the object type: 0 small database label 1 handwritten data 2 stamp 3 annotation label 4 scale 5 swing tag 6 full database label 7 database label 8 swatch 9 institutional label 10 number (ii) then the following four elements are the corner coordinates for the bounding box

Other information available to support this paper: (1) annotations for benchmark dataset (noting these are specific to the MELU trained model) (2) MELU-trained sheet-component object detection model weights (for application in YOLOv5)

Description:

👉 Download the dataset here

This dataset consists of meticulously annotated images of tire side profiles, specifically designed for image segmentation tasks. Each tire has been manually labeled to ensure high accuracy, making this dataset ideal for training machine learning models focused on tire detection, classification, or related automotive applications.

The annotations are provided in the YOLO v5 format, leveraging the PyTorch framework for deep learning applications. The dataset offers a robust foundation for researchers and developers working on object detection, autonomous vehicles, quality control, or any project requiring precise tire identification from images.

Download Dataset

Data Collection and Labeling Process:

Manual Labeling: Every tire in the dataset has been individually labeled to guarantee that the annotations are highly precise, significantly reducing the margin of error in model training.

Annotation Format: YOLO v5 PyTorch format, a highly efficient and widely used format for real-time object detection systems.

Pre-processing Applied:

Auto-orientation: Pixel data has been automatically oriented, and EXIF orientation metadata has been stripped to ensure uniformity across all images, eliminating issues related to

image orientation during processing.

Resizing: All images have been resized to 416×416 pixels using stretching to maintain compatibility with common object detection frameworks like YOLO. This resizing standardizes the image input size while preserving visual integrity.

Applications:

Automotive Industry: This dataset is suitable for automotive-focused AI models, including tire quality assessment, tread pattern recognition, and autonomous vehicle systems.

Surveillance and Security: Use cases in monitoring systems where identifying tires is crucial for vehicle recognition in parking lots or traffic management systems.

Manufacturing and Quality Control: Can be used in tire manufacturing processes to automate defect detection and classification.

Dataset Composition:

Number of Images: [Add specific number]

File Format: JPEG/PNG

Annotation Format: YOLO v5 PyTorch

Image Size: 416×416 (standardized across all images)

This dataset is sourced from Kaggle.

Personal Protective Equipment Dataset (PPED)

This dataset serves as a benchmark for PPE in chemical plants
We provide datasets and experimental results.

1. The dataset

We produced a data set based on the actual needs and relevant regulations in chemical plants.
The standard GB 39800.1-2020 formulated by the Ministry of Emergency Management of the People’s Republic of China defines the protective requirements for plants and chemical laboratories.
The complete dataset is contained in the folder PPED/data.

1.1. Image collection

We took more than 3300 pictures.
We set the following different characteristics, including different environments, different distances, different lighting conditions, different angles, and the diversity of the number of people photographed.

• Backgrounds: There are 4 backgrounds, including office, near machines, factory and regular outdoor scenes.
• Scale: By taking pictures from different distances, the captured PPEs are classified in small, medium and large scales.
• Light: Good lighting conditions and poor lighting conditions were studied.
• Diversity: Some images contain a single person, and some contain multiple people.
• Angle: The pictures we took can be divided into front and side.

A total of more than 3300 photos were taken in the raw data under all conditions.
All images are located in the folder “PPED/data/JPEGImages”.

1.2. Label

We use Labelimg as the labeling tool, and we use the PASCAL-VOC labelimg format.
Yolo use the txt format, we can use trans_voc2yolo.py to convert the XML file in PASCAL-VOC format to txt file.
Annotations are stored in the folder PPED/data/Annotations

1.3. Dataset Features

The pictures are made by us according to the different conditions mentioned above.
The file PPED/data/feature.csv is a CSV file which notes all the .os of all the image. It records every feature of the picture, including lighting conditions, angles, backgrounds, number of people and scale.

1.4. Dataset Division

The data set is divided into 9:1 training set and test set.

2. Baseline Experiments

We provide baseline results with five models, namely Faster R-CNN ®, Faster R-CNN (M), SSD, YOLOv3-spp, and YOLOv5.
All code and results is given in folder PPED/experiment.

2.1. Environment and Configuration:

• Intel Core i7-8700 CPU
• NVIDIA GTX1060 GPU
• 16 GB of RAM
• Python: 3.8.10
• pytorch: 1.9.0
• pycocotools: pycocotools-win
• Windows 10

2.2. Applied Models

The source codes and results of the applied models is given in folder PPED/experiment with sub-folders corresponding to the model names.

2.2.1. Faster R-CNN

• Faster R-CNN
  • backbone: resnet50+fpn
    • We downloaded the pre-training weights from https://download.pytorch.org/models/fasterrcnn_resnet50_fpn_coco-258fb6c6.pth.
    • We modified the dataset path, training classes and training parameters including batch size.
    • We run train_res50_fpn.py start training.
    • Then, the weights are trained by the training set.
    • Finally, we validate the results on the test set.
  • backbone: mobilenetv2
    • the same training method as resnet50+fpn, but the effect is not as good as resnet50+fpn, so it is directly discarded.

The Faster R-CNN source code used in our experiment is given in folder PPED/experiment/Faster R-CNN.
The weights of the fully-trained Faster R-CNN (R), Faster R-CNN (M) model are stored in file PPED/experiment/trained_models/resNetFpn-model-19.pth and mobile-model.pth.
The performance measurements of Faster R-CNN (R) Faster R-CNN (M) are stored in folder PPED/experiment/results/Faster RCNN(R)and Faster RCNN(M).

2.2.2. SSD

• backbone: resnet50
• We downloaded pre-training weights from https://download.pytorch.org/models/resnet50-19c8e357.pth.
• The same training method as Faster R-CNN is applied.

The SSD source code used in our experiment is given in folder PPED/experiment/ssd.
The weights of the fully-trained SSD model are stored in file PPED/experiment/trained_models/SSD_19.pth.
The performance measurements of SSD are stored in folder PPED/experiment/results/SSD.

2.2.3. YOLOv3-spp

• backbone: DarkNet53
• We modified the type information of the XML file to match our application.
• We run trans_voc2yolo.py to convert the XML file in VOC format to a txt file.
• The weights used are: yolov3-spp-ultralytics-608.pt.

The YOLOv3-spp source code used in our experiment is given in folder PPED/experiment/YOLOv3-spp.
The weights of the fully-trained YOLOv3-spp model are stored in file PPED/experiment/trained_models/YOLOvspp-19.pt.
The performance measurements of YOLOv3-spp are stored in folder PPED/experiment/results/YOLOv3-spp.

2.2.4. YOLOv5

• backbone: CSP_DarkNet
• We modified the type information of the XML file to match our application.
• We run trans_voc2yolo.py to convert the XML file in VOC format to a txt file.
• The weights used are: yolov5s.

The YOLOv5 source code used in our experiment is given in folder PPED/experiment/yolov5.
The weights of the fully-trained YOLOv5 model are stored in file PPED/experiment/trained_models/YOLOv5.pt.
The performance measurements of YOLOv5 are stored in folder PPED/experiment/results/YOLOv5.

2.3. Evaluation

The computed evaluation metrics as well as the code needed to compute them from our dataset are provided in the folder PPED/experiment/eval.

3. Code Sources

1. Faster R-CNN (R and M)
   • https://github.com/WZMIAOMIAO/deep-learning-for-image-processing/tree/master/pytorch_object_detection/faster_rcnn
   • official code: https://github.com/pytorch/vision/blob/main/torchvision/models/detection/faster_rcnn.py
2. SSD
   • https://github.com/WZMIAOMIAO/deep-learning-for-image-processing/tree/master/pytorch_object_detection/ssd
   • official code: https://github.com/pytorch/vision/blob/main/torchvision/models/detection/ssd.py
3. YOLOv3-spp
   • https://github.com/WZMIAOMIAO/deep-learning-for-image-processing/tree/master/pytorch_object_detection/yolov3-spp
4. YOLOv5
   • https://github.com/ultralytics/yolov5

🦷 OPG Dataset for Kennedy Classification of Partially Edentulous Arches 🦷

This dataset provides orthopantomography (OPG) dental x-ray images annotated for:

• Broken Roots
• Periodontally Compromised Teeth
• Kennedy Classification of Partially Edentulous Arches (Class I-IV)

A valuable resource for dental AI research and object detection tasks. 🧑‍⚕️💻

📁 File Structure

• /images/
  Contains OPG dental x-ray images in JPG/PNG format. 🖼️

• /annotations/
  Contains annotation files. Format details below. 📝

• README.txt
  This documentation file. 📖

• /code/ (optional)
  Sample scripts for training or evaluation. 💻

🏷️ Annotation Details

Annotations include:

• 🔲 Bounding boxes for:

  • Broken roots
  • Periodontally compromised teeth

• 🏷️ Classification labels for:

  • Kennedy Class I, II, III, or IV arches

Format:
YOLOv5-style format:
[class_id x_center y_center width height] (normalized)

Class IDs:

0 - Broken Root 1 - Periodontally Compromised Tooth 2 - Kennedy Class I 3 - Kennedy Class II 4 - Kennedy Class III 5 - Kennedy Class IV

⚙️ How to Use

You can use this dataset with popular object detection frameworks like:

• YOLOv5 / YOLOv8
• MMDetection
• Detectron2
• TensorFlow Object Detection API

Sample scripts are provided in the /code/ folder to help you get started. ⚙️

🚀 Steps to Reproduce

1. Download and extract the dataset.
2. Install required dependencies (e.g., PyTorch, torchvision, OpenCV).
3. Edit the training script paths to match your directory.
4. Train your model using your chosen framework.

See README.txt and any provided scripts for detailed guidance.

🏢 Institutions

This dataset was developed in collaboration between:

• 🇸🇦 King Faisal University
• 🇵🇰 Shaheed Zulfiqar Ali Bhutto Medical University
• 🇵🇰 NED University of Engineering and Technology

📜 License

Released under the Creative Commons Attribution 4.0 International (CC BY 4.0) License.

✔️ You are free to use, modify, and distribute — even commercially — with proper credit.

✍️ Citation

Please cite this dataset as:

Waqas, Maria; Hasan, Shehzad; Khurshid, Zohaib; Kazmi, Shakeel (2024),
“OPG Dataset for Kennedy Classification of Partially Edentulous Arches”,
Mendeley Data, V1, doi: 10.17632/ccw5mvg69r.1

🙏 Support My Work

If you find this dataset valuable for your research or projects, please consider giving it an upvote 👍
Your support encourages sharing more useful and high-quality resources with the community! 😊

Notice: We have currently a paper under double-blind review that introduces this dataset. Therefore, we have anonymized the dataset authorship. Once the review process has concluded, we will update the authorship information of this dataset.

Chinese Chemical Safety Signs (CCSS)

This dataset is compiled as a benchmark for recognizing chemical safety signs from images. We provide both the dataset and the experimental results at doi:10.5281/zenodo.5482334.

1. The Dataset

The complete dataset is contained in the folder ccss/data in archive css_data.zip. The images include signs based on the Chinese standard "Safety Signs and their Application Guidelines" (GB 2894-2008) for safety signs in chemical environments. This standard, in turn, refers to the standards ISO 7010 (Graphical symbols – Safety Colours and Safety Signs – Safety signs used in workplaces and public areas), GB/T 10001 (Public Information Graphic Symbols for Signs), and GB 13495 (Fire Safety Signs)

1.1. Image Collection

We collect photos commonly used chemical safety signs in chemical laboratories and chemical teaching buildings. For a discussion of the standards we base our collections, refer to the book "Talking about Hazardous Chemicals and Safety Signs" for common signs, and refer to the safety signs guidelines (GB 2894-2008).

The shooting was mainly carried out in 6 locations, namely on the road, in a parking lot, construction walls, in a chemical laboratory, outside near big machines, and inside the factory and corridor.

Shooting scale: Images in which the signs appear in small, medium and large scales were taken for each location by shooting photos from different distances.

Shooting light: good lighting conditions and poor lighting conditions were investigated.

Part of the images contain multiple targets and the other part contains only single signs.

Under all conditions, a total of 4650 photos were taken in the original data. These were expanded to 27'900 photos were via data enhancement. All images are located in folder ccss/data/JPEGImages.

The file ccss/data/features/enhanced_data_to_original_data.csv provides a mapping between the enhanced image name and the corresponding original image.

1.2. Annotation and Labelling

The labelling tool is Labelimg, which uses the PASCAL-VOC labelling format. The annotation is stored in the folder ccss/data/Annotations.

Faster R-CNN and SSD are two algorithms that use this format. When training YOLOv5, you can run trans_voc2yolo.py to convert the XML file in PASCAL-VOC format to a txt file.

We provide further meta-information about the dataset in form of a CSV file features.csv which notes, for each image, which other features it has (lighting conditions, scale, multiplicity, etc.).

1.3. Dataset Features

As stated above, the images have been shot under different conditions. We provide all the feature information in folder ccss/data/features. For each feature, there is a separate list of file names in that folder. The file ccss/data/features/features_on_original_data.csv is a CSV file which notes all the features of each original image.

1.4. Dataset Division

The data set is fixedly divided into 7:3 training set and test set. You can find the corresponding image names in the files ccss/data/training_data_file_names.txt and ccss/data/test_data_file_names.txt.

1. Baseline Experiments

We provide baseline results with the three models of Faster R-CNN, SSD, and YOLOv5. All code and results is given in folder ccss/experiment in archive ccss_experiment.

2.2. Environment and Configuration

Single Intel Core i7-8700 CPU

NVIDIA GTX1060 GPU

16 GB of RAM

Python: 3.8.10

pytorch: 1.9.0

pycocotools: pycocotools-win

Visual Studio 2017

Windows 10

2.3. Applied Models

The source codes and results of the applied models is given in folder ccss/experiment with sub-folders corresponding to the model names.

2.3.1. Faster R-CNN

backbone: resnet50+fpn.

we downloaded the pre-training weights from

we modify the type information of the JSON file to match our application.

run train_res50_fpn.py

finally, the weights trained by the training set.

backbone: mobilenetv2

the same training method as resnet50+fpn, but the effect is not as good as resnet50+fpn, so it is directly discarded.

The Faster R-CNN source code used in our experiment is given in folder ccss/experiment/sources/faster_rcnn. The weights of the fully-trained Faster R-CNN model are stored in file ccss/experiment/trained_models/faster_rcnn.pth. The performance measurements of Faster R-CNN are stored in folder ccss/experiment/performance_indicators/faster_rcnn.

2.3.2. SSD

backbone: resnet50

we downloaded pre-training weights from

the same training method as Faster R-CNN is applied.

The SSD source code used in our experiment is given in folder ccss/experiment/sources/ssd. The weights of the fully-trained SSD model are stored in file ccss/experiment/trained_models/ssd.pth. The performance measurements of SSD are stored in folder ccss/experiment/performance_indicators/ssd.

2.3.4. YOLOv5

backbone: CSP_DarkNet

we modified the type information of the YML file to match our application

run trans_voc2yolo.py to convert the XML file in VOC format to a txt file.

the weights used are: yolov5s.

The YOLOv5 source code used in our experiment is given in folder ccss/experiment/sources/yolov5. The weights of the fully-trained YOLOv5 model are stored in file ccss/experiment/trained_models/yolov5.pt. The performance measurements of YOLOv5 are stored in folder ccss/experiment/performance_indicators/yolov5.

2.4. Evaluation

The computed evaluation metrics as well as the code needed to compute them from our dataset are provided in the folder ccss/experiment/performance_indicators. They are provided over the complete test st as well as separately for the image features (over the test set).

1. Code Sources

Faster R-CNN

official code:

SSD

official code:

YOLOv5

We are particularly thankful to the author of the GitHub repository WZMIAOMIAO/deep-learning-for-image-processing (with whom we are not affiliated). Their instructive videos and codes were most helpful during our work. In particular, we based our own experimental codes on his work (and obtained permission to include it in this archive).

1. Licensing

While our dataset and results are published under the Creative Commons Attribution 4.0 License, this does not hold for the included code sources. These sources are under the particular license of the repository where they have been obtained from (see Section 3 above).

Dataset for the GBR competition in YOLOv5 format with additional annotations compared to the original Dataset made with Roboflow tool

Data abstract:
The YogDATA dataset contains images from an industrial laboratory production line when it is functioned to quality yogurts. The case-study for the recognition of yogurt cups requires training of Mask R-CNN and YOLO v5.0 models with a set of corresponding images. Thus, it is important to collect the corresponding images to train and evaluate the class. Specifically, the YogDATA dataset includes the same labeled data for Mask R-CNN (coco format) and YOLO models. For the YOLO architecture, training and validation datsets include sets of images in jpg format and their annotations in txt file format. For the Mask R-CNN architecture, the annotation of the same sets of images are included in json file format (80% of images and annotations of each subset are in training set and 20% of images of each subset are in test set.)

Paper abstract:
The explosion of the digitisation of the traditional industrial processes and procedures is consolidating a positive impact on modern society by offering a critical contribution to its economic development. In particular, the dairy sector consists of various processes, which are very demanding and thorough. It is crucial to leverage modern automation tools and through-engineering solutions to increase their efficiency and continuously meet challenging standards. Towards this end, in this work, an intelligent algorithm based on machine vision and artificial intelligence, which identifies dairy products within production lines, is presented. Furthermore, in order to train and validate the model, the YogDATA dataset was created that includes yogurt cups within a production line. Specifically, we evaluate two deep learning models (Mask R-CNN and YOLO v5.0) to recognise and detect each yogurt cup in a production line, in order to automate the packaging processes of the products. According to our results, the performance precision of the two models is similar, estimating its at 99\%.

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/

Context

I made this data annotation for conference paper . I try to make an application that will be fast and light enough to deploy in any cutting edge device while maintaining a good accuracy like any state-of-the-art model.

Data Details

The following pre-processing was applied to each image: * Auto-orientation of pixel data (with EXIF-orientation stripping) * Resize to 416x416 (Stretch)

The following augmentation was applied to create 3 versions of each source image in trainig set images: * 50% probability of horizontal flip * 50% probability of vertical flip * Equal probability of one of the following 90-degree rotations: none, clockwise, counter-clockwise, upside-down * Randomly crop between 0 and 7 percent of the image * Random rotation of between -40 and +40 degrees * Random shear of between -29° to +29° horizontally and -15° to +15° vertically * Random exposure adjustment of between -34 and +34 percent * Random Gaussian blur of between 0 and 1.5 pixels * Salt and pepper noise was applied to 4 percent of pixels

Acknowledgements

A big shoutout to Massey University for making this dataset public. The original dataset Link is : here , Please keep in mind that the original dataset maybe updated from time to time. However, I don't intend to update this annotated version.