Dataset

This dataset was created by Shakhrul Iman Siam

Contents

Convert Voc To Pytorch

## Overview

Convert Voc To Pytorch is a dataset for object detection tasks - it contains Ls annotations for 11,828 images.

## Getting Started

You can download this dataset for use within your own projects, or fork it into a workspace on Roboflow to create your own model.

  ## License

  This dataset is available under the [CC BY 4.0 license](https://creativecommons.org/licenses/CC BY 4.0).

Test Yolo V5 PyTorch

## Overview

Test Yolo V5 PyTorch is a dataset for object detection tasks - it contains Test annotations for 637 images.

## Getting Started

You can download this dataset for use within your own projects, or fork it into a workspace on Roboflow to create your own model.

  ## License

  This dataset is available under the [CC BY 4.0 license](https://creativecommons.org/licenses/CC BY 4.0).

https://i.imgur.com/s4PgS4X.gif" alt="CreateML Output">

Info

The dataset contains 7 classes of underwater creatures with provided bboxes locations for every animal. The dataset is already split into the train, validation, and test sets.

Data

It includes 638 images. - Creatures are annotated in YOLO v5 PyTorch format

Pre-Processing

The following pre-processing was applied to each image: - Auto-orientation of pixel data (with EXIF-orientation stripping) - Resize to 1024x1024 (Fit within)

Class Breakdown

The following classes are labeled: ['fish', 'jellyfish', 'penguin', 'puffin', 'shark', 'starfish', 'stingray']. Most images contain multiple bounding boxes.

https://i.imgur.com/lFzeXsT.png" alt="Class Balance">

The Fish Detection AI project aims to improve the efficiency of fish monitoring around marine energy facilities to comply with regulatory requirements. Despite advancements in computer vision, there is limited focus on sonar images, identifying small fish with unlabeled data, and methods for underwater fish monitoring for marine energy.

A YOLO (You Only Look Once) computer vision model was developed using the Eyesea dataset (optical) and sonar images from Alaska Fish and Games to identify fish in underwater environments. Supervised methods were used within YOLO to detect fish based on training using labeled data of fish. These trained models were then applied to different unseen datasets, aiming to reduce the need for labeling datasets and training new models for various locations. Additionally, hyper-image analysis and various image preprocessing methods were explored to enhance fish detection.

In this research we achieved: 1. Enhanced YOLO Performance, as compared to a published article (Xu, Matzner 2018) using earlier yolo versions for fish object identification. Specifically, we achieved a best mean Average Precision (mAP) of 0.68 on the Eyesea optical dataset using YOLO v8 (medium-sized model), surpassing previous YOLO v3 benchmarks from that previous article publication. We further demonstrated up to 0.65 mAP on unseen sonar domains by leveraging a hyper-image approach (stacking consecutive frames), showing promising cross-domain adaptability.

This submission of data includes: - The actual best-performing trained YOLO model neural network weights, which can be applied to do object detection (PyTorch files, .pt). These are found in the Yolo_models_downloaded zip file - Documentation file to explain the upload and the goals of each of the experiments 1-5, as detailed in the word document (named "Yolo_Object_Detection_How_To_Document.docx") - Coding files, namely 5 sub-folders of python, shell, and yaml files that were used to run the experiments 1-5, as well as a separate folder for yolo models. Each of these is found in their own zip file, named after each experiment - Sample data structures (sample1 and sample2, each with their own zip file) to show how the raw data should be structured after running our provided code on the raw downloaded data - link to the article that we were replicating (Xu, Matzner 2018) - link to the Yolo documentation site from the original creators of that model (ultralytics) - link to the downloadable EyeSea data set from PNNL (instructions on how to download and format the data in the right way to be able to replicate these experiments is found in the How To word document)

EfficientDet (PyTorch) This is a work in progress PyTorch implementation of EfficientDet.

It is based on the

official Tensorflow implementation by Mingxing Tan and the Google Brain team paper by Mingxing Tan, Ruoming Pang, Quoc V. Le EfficientDet: Scalable and Efficient Object Detection I am aware there are other PyTorch implementations. Their approach didn't fit well with my aim to replicate the Tensorflow models closely enough to allow weight ports while still maintaining a PyTorch feel and a high degree of flexibility for future additions. So, this is built from scratch and leverages my previous EfficientNet work.

Updates / Tasks 2020-4-15 Taking a pause on training, some high priority things came up. There are signs of life on the training branch, was working the basic augs before priority switch, loss fn appeared to be doing something sane with distributed training working, no proper eval yet, init not correct yet. I will get to it, with SOTA training config and good performance as the end goal (as with my EfficientNet work).

2020-04-11 Cleanup post-processing. Less code and a five-fold throughput increase on the smaller models. D0 running > 130 img/s on a single 2080Ti, D1 > 130 img/s on dual 2080Ti up to D7 @ 8.5 img/s.

2020-04-10 Replace generate_detections with PyTorch impl using torchvision batched_nms. Significant performance increase with minor (+/-.001 mAP) score differences. Quite a bit faster than original TF impl on a GPU now.

2020-04-09 Initial code with working validation posted. Yes, it's a little slow, but I think faster than the official impl on a GPU if you leave AMP enabled. Post processing needs some love.

Core Tasks Feature extraction from my EfficientNet implementations (https://github.com/rwightman/gen-efficientnet-pytorch or https://github.com/rwightman/pytorch-image-models) Low level blocks / helpers (SeparableConv, create_pool2d (same padding), etc) PyTorch implementation of BiFPN, BoxNet, ClassNet modules and related submodules Port Tensorflow checkpoints to PyTorch -- initial D1 checkpoint converted, state_dict loaded, on to validation.... Basic MS COCO validation script Temporary (hacky) COCO dataset and transform Port reference TF anchor and object detection code Verify model output sanity Integrate MSCOCO eval metric calcs Some cleanup, testing Submit to test-dev server, all good Add torch hub support and pretrained URL based weight download Change module dependencies from 'timm' to minimal 'geffnet' for backbone, bring some of the layers here leaving as timm for now, as the training code will use many timm functions that I leverage to reproduce SOTA EfficientNet training in PyTorch Remove redundant bias layers that exist in the official impl and weights Add visualization support Performance improvements, numpy TF detection code -> optimized PyTorch Verify/fix Torchscript and ONNX export compatibility Possible Future Tasks Training (object detection) reimplementation w/ Rand/AutoAugment, etc Training (semantic segmentation) experiments Integration with Detectron2 / MMDetection codebases Addition and cleanup of EfficientNet based U-Net and DeepLab segmentation models that I've used in past projects Addition and cleanup of OpenImages dataset/training support from a past project Exploration of instance segmentation possibilities... If you are an organization is interested in sponsoring and any of this work, or prioritization of the possible future directions interests you, feel free to contact me (issue, LinkedIn, Twitter, hello at rwightman dot com). I will setup a github sponser if there is any interest.

Models Variant Download mAP (val2017) mAP (test-dev2017) mAP (Tensorflow official test-dev2017) D0 tf_efficientdet_d0.pth 32.8 TBD 33.8 D1 tf_efficientdet_d1.pth 38.5 TBD 39.6 D2 tf_efficientdet_d2.pth 42.0 42.5 43 D3 tf_efficientdet_d3.pth 45.3 TBD 45.8 D4 tf_efficientdet_d4.pth 48.3 TBD 49.4 D5 tf_efficientdet_d5.pth 49.6 TBD 50.7 D6 tf_efficientdet_d6.pth 50.6 TBD 51.7 D7 tf_efficientdet_d7.pth 50.9 51.2 52.2 Usage Environment Setup Tested in a Python 3.7 or 3.8 conda environment in Linux with:

PyTorch 1.4 PyTorch Image Models (timm) 0.1.20, pip install timm or local install from (https://github.com/rwightman/pytorch-image-models) Apex AMP master (as of 2020-04) NOTE - There is a conflict/bug with Numpy 1.18+ and pycocotools, force install numpy <= 1.17.5 or the coco eval will fail, the validation script will still save the output JSON and that can be run through eval again later.

Dataset Setup MSCOCO 2017 validation data:

wget http://images.cocodataset.org/zips/val2017.zip wget http://images.cocodataset.org/annotations/annotations_trainval2017.zip unzip val2017.zip unzip annotations_trainval2017.zip MSCOCO 2017 test-dev data:

wget http://images.cocodataset.org/zips/test2017.zip unzip -q test2017.zip wget http://images.cocodat...

Pytorch

## Overview

Pytorch is a dataset for object detection tasks - it contains Test annotations for 1,277 images.

## Getting Started

You can download this dataset for use within your own projects, or fork it into a workspace on Roboflow to create your own model.

  ## License

  This dataset is available under the [CC BY 4.0 license](https://creativecommons.org/licenses/CC BY 4.0).

About

Helper codes used in TORCHVISION OBJECT DETECTION FINETUNING TUTORIAL

original -> GitHub Page

Fish PYTORCH

## Overview

Fish PYTORCH is a dataset for object detection tasks - it contains Fishes annotations for 2,975 images.

## Getting Started

You can download this dataset for use within your own projects, or fork it into a workspace on Roboflow to create your own model.

  ## License

  This dataset is available under the [CC BY 4.0 license](https://creativecommons.org/licenses/CC BY 4.0).

MMDetection3D is an open source object detection toolbox based on PyTorch, towards the next-generation platform for general 3D detection. It is a part of the OpenMMLab project.

Dataset:

https://universe.roboflow.com/brain-tumor-detection-wsera/tumor-detection-ko5jp/dataset/8

Environment setup:

Ultralytics recommend to install pytorch first from official website as per your cuda version- ```python https://pytorch.org/get-started/locally.

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

pip install Ultralytics download ```

WeedCrop Image Dataset

Data Description

It includes 2822 images. Weed are annotated in YOLO v5 PyTorch format.

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

The following augmentation was applied to create 3 versions of each source image: * Equal probability of one of the following 90-degree rotations: none, clockwise, counter-clockwise * Random shear of between -15° to +15° horizontally and -15° to +15° vertically * Random brigthness adjustment of between -25 and +25 percent

Classes

Crop, Weed

Inspiration

Identifying weeds and distinguish them from crops is very essential in Farming.

Acknowledgements

This dataset is derived by the following publication:

Kaspars Sudars, Janis Jasko, Ivars Namatevs, Liva Ozola, Niks Badaukis, Dataset of annotated food crops and weed images for robotic computer vision control, Data in Brief, Volume 31, 2020, 105833, ISSN 2352-3409, https://doi.org/10.1016/j.dib.2020.105833. (https://www.sciencedirect.com/science/article/pii/S2352340920307277) Abstract: Weed management technologies that can identify weeds and distinguish them from crops are in need of artificial intelligence solutions based on a computer vision approach, to enable the development of precisely targeted and autonomous robotic weed management systems. A prerequisite of such systems is to create robust and reliable object detection that can unambiguously distinguish weed from food crops. One of the essential steps towards precision agriculture is using annotated images to train convolutional neural networks to distinguish weed from food crops, which can be later followed using mechanical weed removal or selected spraying of herbicides. In this data paper, we propose an open-access dataset with manually annotated images for weed detection. The dataset is composed of 1118 images in which 6 food crops and 8 weed species are identified, altogether 7853 annotations were made in total. Three RGB digital cameras were used for image capturing: Intel RealSense D435, Canon EOS 800D, and Sony W800. The images were taken on food crops and weeds grown in controlled environment and field conditions at different growth stages Keywords: Computer vision; Object detection; Image annotation; Precision agriculture; Crop growth and development

Many thanks to Roboflow team for sharing this data.

Yolo To COCO For SSD Pytorch

## Overview

Yolo To COCO For SSD Pytorch is a dataset for object detection tasks - it contains Car Van Truck Bus Person Cyclist annotations for 5,981 images.

## Getting Started

You can download this dataset for use within your own projects, or fork it into a workspace on Roboflow to create your own model.

  ## License

  This dataset is available under the [MIT license](https://creativecommons.org/licenses/MIT).

This dataset is currently the largest public dataset on computer motherboard defects for object detection models, formatted for YOLOv5 (PyTorch), YOLOv7 (PyTorch), YOLOv8 and CLIP. It contains more than 1000 items and 2800 annotations on commonly seen motherboard production defects such as loose / misused screws, detached CPU fan ports, scratches, and so on. Download links in README.md file :) , sample images available.

Pothole Yolov3 Pytorch

## Overview

Pothole Yolov3 Pytorch is a dataset for object detection tasks - it contains Pothole annotations for 665 images.

## Getting Started

You can download this dataset for use within your own projects, or fork it into a workspace on Roboflow to create your own model.

  ## License

  This dataset is available under the [CC BY 4.0 license](https://creativecommons.org/licenses/CC BY 4.0).

Pytorch OCR

## Overview

Pytorch OCR is a dataset for object detection tasks - it contains Numbers annotations for 777 images.

## Getting Started

You can download this dataset for use within your own projects, or fork it into a workspace on Roboflow to create your own model.

  ## License

  This dataset is available under the [CC BY 4.0 license](https://creativecommons.org/licenses/CC BY 4.0).

We evaluated our AHOD model using two well-known datasets in the field of object detection:COCO (Common Objects in Context)One of the most widely used benchmarks for object detection.Contains over 200,000 images and more than 80 object categories.Includes objects in varied and sometimes cluttered contexts, allowing the robustness of detectors to be evaluated.Pascal VOCAnother reference dataset, often used for classification, detection and segmentation tasks.Includes 20 object categories, with precise bounding box annotations.Less complex than COCO, but useful for comparing performance on more conventional objects.Tools, techniques and innovations usedThe AHOD architecture is based on three main modules:Feature Pyramid Enhancement (FPE)Multi-scale feature processing tool.Improves the representation of objects of various sizes in the same image.Inspired by architectures such as FPN (Feature Pyramid Networks), but optimised for better performance.Dynamic Context Module (DCM)Intelligent contextual module.Capable of dynamically adjusting the extracted features according to the context (e.g. by adapting the features according to urban or rural areas in a road image).Enhances the model's ability to understand the overall context of the scene.Fast and Accurate Detection Head (FADH)Optimised detection head.Seeks a compromise between the speed of YOLO and the accuracy of Faster R-CNN.Probably uses lightweight convolution layers or optimisations such as MobileNet/Depthwise Convolutions.Probable technologies usedAlthough the summary does not specify this, we can reasonably assume that the following tools are used:Deep learning frameworks: PyTorch or TensorFlow, which are standard in object detection research.GPUs for training and inference, particularly for measuring inference times (essential in real-time applications).Standard evaluation techniques:mAP (mean Average Precision): measure of average precision.FPS (Frames Per Second) or inference time for real-time performance.

This dataset loads torchvision reference detection scripts in kaggle kernels. Scripts are located in torchvision reference detection official github repo

Object detection reference training scripts

This folder contains reference training scripts for object detection. They serve as a log of how to train specific models, to provide baseline training and evaluation scripts to quickly bootstrap research.

To execute the example commands below you must install the following:

cython
pycocotools
matplotlib

You must modify the following flags:

--data-path=/path/to/coco/dataset

`--nproc_per_node=

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.

1. The Dataset

The complete dataset is contained in the folder ccss/data. 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 of commonly used chemical safety signs in chemical laboratories and chemistry teaching. 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 Labelimg

We use Labelimg as labeling tool, which, in turn, uses the PASCAL-VOC labelimg 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.). We apply the COCO standard for deciding whether a target is small, medium, or large in size.

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.

2. Baseline Experiments

We provide baseline results with five models, namely Faster R-CNN (R), Faster R-CNN (M), SSD, YOLOv3-spp, and YOLOv5. All code and results is given in folder 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

• Faster R-CNN (R) has the backbone resnet50+fpn.
  • we downloaded the pre-training weights from https://download.pytorch.org/models/fasterrcnn_resnet50_fpn_coco-258fb6c6.pth
  • 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.
  The Faster R-CNN (R) source code used in our experiment is given in folder ccss/experiment/sources/faster_rcnn (R). The weights of the fully-trained Faster R-CNN (R) model are stored in file ccss/experiment/trained_models/faster_rcnn (R).pth. The performance measurements of Faster R-CNN (R) are stored in folder ccss/experiment/performance_indicators/faster_rcnn (R).
• Faster R-CNN (M) has the backbone mobilenetv2.
  • backbone: MobileNetV2.
  • we modify the type information of the JSON file to match our application.
  • run train_mobilenetv2.py
  • finally, the weights trained by the training set.
  The Faster R-CNN (M) source code used in our experiment is given in folder ccss/experiment/sources/faster_rcnn (M). The weights of the fully-trained Faster R-CNN (M) model are stored in file ccss/experiment/trained_models/faster_rcnn (M).pth. The performance measurements of Faster R-CNN (M) are stored in folder ccss/experiment/performance_indicators/faster_rcnn (M).

2.3.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 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.3. YOLOv3-spp

• backbone: DarkNet53
• we modified the type information of the XML 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: yolov3-spp-ultralytics-608.pt.

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

2.3.4. YOLOv5

• backbone: CSP_DarkNet
• we modified the type information of the XML 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).

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

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

OSCAR, the Occluded Stereo dataset for Convolutional Architectures with Recurrence. Version: 2.0
(dataset as presented in our JOV 2021 journal publication "Recurrent Processing Improves Occluded Object Recognition and Gives Rise to Perceptual Hysteresis")

If you make use of the dataset, please cite as follows:

Ernst, M. R., Burwick, T., & Triesch, J. (2021). Recurrent Processing Improves Occluded Object Recognition and Gives Rise to Perceptual Hysteresis. In Journal of Vision

Contents

• readme.md - detailed description and sample pictures
• img.zip - folder that contains images for the readme file
• licence.md - licence agreement for using the datasets
• os-fmnist2c.zip - compressed archive of the occluded stereo FashionMNIST dataset (centered, ~1.1GB)
• os-fmnist2r.zip - compressed archive of the occluded stereo FashionMNIST dataset (random, ~1.2GB)
• os-mnist2c.zip - compressed archive of the occluded stereo MNIST dataset (centered, ~865MB)
• os-mnist2r.zip - compressed archive of the occluded stereo MNIST dataset (random, ~851MB)
• os-ycb2.zip - compressed archive of the occluded stereo ycb-object dataset (~1.1GB)
• os-ycb2_highres.zip - compressed archive of the occluded stereo ycb-object dataset (high resolution, ~9.8GB)
• OSCARv2_dataset.py - python script to directly load image data from folder, pytorch dataset