OpenCV implementation of Torchvision transforms, from https://github.com/YU-Zhiyang/opencv_transforms_torchvision

Why? Because opencv is faster than PIL

To use do

package_path = '../input/cvtorchvision/opencv_transforms_torchvision-master/'

sys.path.append(package_path)

from cvtorchvision import cvtransforms

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=

About

Helper codes used in TORCHVISION OBJECT DETECTION FINETUNING TUTORIAL

original -> GitHub Page

Dataset

This dataset was created by Alex K

Contents

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.

1. 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.

1. Code Sources

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

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

YOLOv3-spp

https://github.com/WZMIAOMIAO/deep-learning-for-image-processing/tree/master/pytorch_object_detection/yolov3-spp

YOLOv5

https://github.com/ultralytics/yolov5

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

FFHQ Dataset (pravsels/FFHQ_1024) encoded using the dc-ae-f128c512-mix-1.0 auto encoder. Example usage import sys sys.path.append('../dcae') # https://github.com/vladmandic/dcae from dcae import DCAE

from datasets import load_dataset import torch import torchvision

dataset = load_dataset("SwayStar123/FFHQ_1024_DC-AE_f128", split="train") dc_ae = DCAE("dc-ae-f128c512-mix-1.0", device="cuda", dtype=torch.bfloat16).eval() # Must be bfloat. with float16 it produces terrible outputs.

def… See the full description on the dataset page: https://huggingface.co/datasets/SwayStar123/FFHQ_1024_DC-AE_f128.

This repository contains the data and code necessary to derive the main results of the paper “An optical neural network using less than 1 photon per multiplication”. It includes the datasets generated during the characterization of dot-product accuracy (Figure 2) and the execution of the ONN using different photon budgets (Figure 3), along with the code used to analyze them. Besides, the codes for training the neural network model and collecting data in the experimental setup are also included.

The scripts and data in "Figure 2.zip" ("Figure 3.zip") were used to generate Figure 2 (Figure 3) in the main manuscript.

"ONN-device-control.zip" contains the device control codes in the experiments for data collection, available at https://github.com/mcmahon-lab/ONN-device-control.

"ONN-QAT-SQL.zip" contains the trained model and training scripts (Python 3.8.3, PyTorch version 1.7.0, torchvision version 0.8.1) for the neural network executed in the experiment, available at https://github.com/mcmahon-lab/ONN-QAT-SQL.

For more details, please refer to the README files in the root directory and each separate folder.

Taken from the README of the google-research/big_transfer repo:

Big Transfer (BiT): General Visual Representation Learning

by Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Joan Puigcerver, Jessica Yung, Sylvain Gelly, Neil Houlsby

Introduction

In this repository we release multiple models from the Big Transfer (BiT): General Visual Representation Learning paper that were pre-trained on the ILSVRC-2012 and ImageNet-21k datasets. We provide the code to fine-tuning the released models in the major deep learning frameworks TensorFlow 2, PyTorch and Jax/Flax.

We hope that the computer vision community will benefit by employing more powerful ImageNet-21k pretrained models as opposed to conventional models pre-trained on the ILSVRC-2012 dataset.

We also provide colabs for a more exploratory interactive use: a TensorFlow 2 colab, a PyTorch colab, and a Jax colab.

Installation

Make sure you have Python>=3.6 installed on your machine.

To setup Tensorflow 2, PyTorch or Jax, follow the instructions provided in the corresponding repository linked here.

In addition, install python dependencies by running (please select tf2, pytorch or jax in the command below): pip install -r bit_{tf2|pytorch|jax}/requirements.txt

How to fine-tune BiT

First, download the BiT model. We provide models pre-trained on ILSVRC-2012 (BiT-S) or ImageNet-21k (BiT-M) for 5 different architectures: ResNet-50x1, ResNet-101x1, ResNet-50x3, ResNet-101x3, and ResNet-152x4.

For example, if you would like to download the ResNet-50x1 pre-trained on ImageNet-21k, run the following command: wget https://storage.googleapis.com/bit_models/BiT-M-R50x1.{npz|h5} Other models can be downloaded accordingly by plugging the name of the model (BiT-S or BiT-M) and architecture in the above command. Note that we provide models in two formats: npz (for PyTorch and Jax) and h5 (for TF2). By default we expect that model weights are stored in the root folder of this repository.

Then, you can run fine-tuning of the downloaded model on your dataset of interest in any of the three frameworks. All frameworks share the command line interface python3 -m bit_{pytorch|jax|tf2}.train --name cifar10_`date +%F_%H%M%S` --model BiT-M-R50x1 --logdir /tmp/bit_logs --dataset cifar10 Currently. all frameworks will automatically download CIFAR-10 and CIFAR-100 datasets. Other public or custom datasets can be easily integrated: in TF2 and JAX we rely on the extensible tensorflow datasets library. In PyTorch, we use torchvision’s data input pipeline.

Note that our code uses all available GPUs for fine-tuning.

We also support training in the low-data regime: the `--examples_per_class

Starter Notebook

ABOUT (from project's README)

Keras style model.summary() in PyTorch

Keras has a neat API to view the visualization of the model which is very helpful while debugging your network. Here is a barebone code to try and mimic the same in PyTorch. The aim is to provide information complementary to, what is not provided by print(your_model) in PyTorch.

Usage

• pip install torchsummary or
• git clone https://github.com/sksq96/pytorch-summary

from torchsummary import summary
summary(your_model, input_size=(channels, H, W))

• Note that the input_size is required to make a forward pass through the network.

Examples

CNN for MNIST

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchsummary import summary

class Net(nn.Module):
  def _init_(self):
    super(Net, self)._init_()
    self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
    self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
    self.conv2_drop = nn.Dropout2d()
    self.fc1 = nn.Linear(320, 50)
    self.fc2 = nn.Linear(50, 10)

  def forward(self, x):
    x = F.relu(F.max_pool2d(self.conv1(x), 2))
    x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
    x = x.view(-1, 320)
    x = F.relu(self.fc1(x))
    x = F.dropout(x, training=self.training)
    x = self.fc2(x)
    return F.log_softmax(x, dim=1)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # PyTorch v0.4.0
model = Net().to(device)

summary(model, (1, 28, 28))

----------------------------------------------------------------
    Layer (type)        Output Shape     Param #
================================================================
      Conv2d-1      [-1, 10, 24, 24]       260
      Conv2d-2       [-1, 20, 8, 8]      5,020
     Dropout2d-3       [-1, 20, 8, 8]        0
      Linear-4          [-1, 50]     16,050
      Linear-5          [-1, 10]       510
================================================================
Total params: 21,840
Trainable params: 21,840
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.06
Params size (MB): 0.08
Estimated Total Size (MB): 0.15
----------------------------------------------------------------

VGG16

import torch
from torchvision import models
from torchsummary import summary

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
vgg = models.vgg16().to(device)

summary(vgg, (3, 224, 224))

----------------------------------------------------------------
    Layer (type)        Output Shape     Param #
================================================================
      Conv2d-1     [-1, 64, 224, 224]      1,792
       ReLU-2     [-1, 64, 224, 224]        0
      Conv2d-3     [-1, 64, 224, 224]     36,928
       ReLU-4     [-1, 64, 224, 224]        0
     MaxPool2d-5     [-1, 64, 112, 112]        0
      Conv2d-6    [-1, 128, 112, 112]     73,856
       ReLU-7    [-1, 128, 112, 112]        0
      Conv2d-8    [-1, 128, 112, 112]     147,584
       ReLU-9    [-1, 128, 112, 112]        0
    MaxPool2d-10     [-1, 128, 56, 56]        0
      Conv2d-11     [-1, 256, 56, 56]     295,168
       ReLU-12     [-1, 256, 56, 56]        0
      Conv2d-13     [-1, 256, 56, 56]     590,080
       ReLU-14     [-1, 256, 56, 56]        0
      Conv2d-15     [-1, 256, 56, 56]     590,080
       ReLU-16     [-1, 256, 56, 56]        0
    MaxPool2d-17     [-1, 256, 28, 28]        0
      Conv2d-18     [-1, 512, 28, 28]    1,180,160
       ReLU-19     [-1, 512, 28, 28]        0
      Conv2d-20     [-1, 512, 28, 28]    2,359,808
       ReLU-21     [-1, 512, 28, 28]        0
      Conv2d-22     [-1, 512, 28, 28]    2,359,808
       ReLU-23     [-1, 512, 28, 28]        0
    MaxPool2d-24     [-1, 512, 14, 14]        0
      Conv2d-25     [-1, 512, 14, 14]    2,359,808
       ReLU-26     [-1, 512, 14, 14]        0
      Conv2d-27     [-1, 512, 14, 14]    2,359,808
       ReLU...

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...

MMSegmentation Offine Wheel Version-1.2.2

Example Code

• Train： ``` !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/torch-1.12.1+cu116-cp310-cp310-linux_x86_64.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/torchvision-0.13.1+cu116-cp310-cp310-linux_x86_64.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/mmcv-2.0.1-cp310-cp310-manylinux1_x86_64.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/openmim-0.3.9-py2.py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/mmengine-0.7.4-py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/addict-2.4.0-py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/yapf-0.40.1-py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/einops-0.7.0-py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/terminaltables-3.1.10-py2.py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/ftfy-6.1.3-py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/wcwidth-0.2.12-py2.py3-none-any.whl

!git clone -bv1.2.2 https://github.com/open-mmlab/mmsegmentation.git %cd /kaggle/working/mmsegmentation !pip install -v -e . ```

• Infer： !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/torch-1.12.1+cu116-cp310-cp310-linux_x86_64.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/torchvision-0.13.1+cu116-cp310-cp310-linux_x86_64.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/mmcv-2.0.1-cp310-cp310-manylinux1_x86_64.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/openmim-0.3.9-py2.py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/mmengine-0.7.4-py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/addict-2.4.0-py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/yapf-0.40.1-py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/einops-0.7.0-py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/terminaltables-3.1.10-py2.py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/ftfy-6.1.3-py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/wcwidth-0.2.12-py2.py3-none-any.whl !pip install --no-index --no-deps ../input/mmsegmentation-1-2-2/mmsegmentation-1.2.2-py3-none-any.whl

https://github.com/ultralytics/yolov5

Only clone, not modify because the license.

Configure for one class as Wheat New configure with yolov5x.yaml

Using: !cp -r ../input/all-in-one-yolov5-wheat/yolov5/* . !pip install -r requirements.txt if issue with torch version and torchvission, check version cuda and comeback the old version torch, example cuda 10.1 : !pip install torch==1.5.1+cu101 torchvision==0.6.1+cu101 -f https://download.pytorch.org/whl/torch_stable.html

!git clone https://github.com/NVIDIA/apex && cd apex && pip install -v --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" . --user && cd .. && rm -rf apex

!python train.py --img 1024 --batch 2 --epochs 12 --data ../input/all-in-one-yolov5-wheat/wheat0.yaml --cfg ../input/all-in-one-yolov5-wheat/yolov5x.yaml --name yolov5_fold0 --weights "yolov5x.pt" --adam

These are weights of the ResNet101 model, which was trained on car_color_dataset to determine the color of the vehicle.

This model was used to solve the final task of the RuCode 2022 Festival. Link to the top-5 solution (private_test, f1-score=0.9856): https://github.com/michael-bmstu/RuCode_2022

Github repo for library, https://github.com/FZJ-INM1-BDA/celldetection

Along with these libs, there are the following libs: pandas-1.3.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl scipy-1.7.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl scikit_learn-1.0.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl numpy-1.21.4-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl torch-1.10.0-cp37-cp37m-manylinux1_x86_64.whl torchvision-0.11.1-cp37-cp37m-manylinux1_x86_64.whl opencv_python_headless-4.5.4.60-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl opencv_python-4.5.4.60-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl scikit_image-0.19.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl matplotlib-3.5.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl

To install and use it offline !pip install celldetection --no-index --find-links=../input/celldetectionofflinelibstargz/celldetection-offline-libs

Commands provided for reproducibility ``` !pip download celldetection -d ./celldetection-offline-libs

!find ./celldetection-offline-libs/ -type f -name '*.whl' -size -10M > celldetection-offline-libs.txt

!tar -zcvf celldetection-offline-libs.tar.gz -T celldetection-offline-libs.txt
```

You may refer to this notebook for detailed instructions, pip-installing-packages-with-no-internet