Publish three-class clothing type classifier

.gitignore

@@ -0,0 +1,2 @@
+*.onnx
+*.safetensors

README.md

@@ -1,3 +1,177 @@
 ---
 license: mit
+library_name: timm
+pipeline_tag: image-classification
+base_model: timm/tf_efficientnetv2_s.in21k_ft_in1k
+base_model_relation: finetune
+model_name: Clothing Type EfficientNetV2-S
+metrics:
+  - accuracy
+tags:
+  - image-classification
+  - timm
+  - pytorch
+  - efficientnetv2
+  - onnx
+  - safetensors
+  - clothing-type-classification
 ---
+
+# Clothing Type EfficientNetV2-S
+
+This is a three-class clothing-type image classifier fine-tuned from
+[`timm/tf_efficientnetv2_s.in21k_ft_in1k`](https://huggingface.co/timm/tf_efficientnetv2_s.in21k_ft_in1k).
+It predicts one of the following labels, in model-output order:
+
+| ID | Label |
+|---:|---|
+| 0 | `denim_shorts` |
+| 1 | `lingerie` |
+| 2 | `swim_bikini` |
+
+## Model details
+
+| Property | Value |
+|---|---|
+| Task | Image classification |
+| Architecture | EfficientNetV2-S |
+| Base model | `timm/tf_efficientnetv2_s.in21k_ft_in1k` |
+| Relationship | Full fine-tune |
+| Precision | FP32; not quantized |
+| Parameters | 20,181,331 |
+| Input | RGB image tensor, `N × 3 × 384 × 256` |
+| Output | Three logits in the label order above |
+| ONNX opset | 18 |
+| License | MIT; the base model is Apache-2.0 |
+
+The pretrained 1,000-class head is replaced by a dropout layer with
+probability `0.15` and a three-output linear classifier. The published
+artifacts are full-precision exports, not quantized variants. The ONNX model
+supports dynamic batch sizes and fixes each image to 384 pixels high by 256
+pixels wide.
+
+## Files
+
+- `clothing_type-tf_efficientnetv2_s.in21k_ft_in1k.onnx` is the portable
+  inference graph.
+- `clothing_type-tf_efficientnetv2_s.in21k_ft_in1k.safetensors` contains the
+  PyTorch `EfficientNetClassifier` state dictionary.
+- `config.json` records the architecture, labels, and timm model settings.
+- `preprocessor_config.json` records the image preprocessing contract.
+
+The safetensors keys include the custom wrapper's `model.` prefix and custom
+classifier head. Load them with the `EfficientNetClassifier` implementation
+from the [source repository](https://github.com/mr-szgz/clothing-classification-model),
+not as an unmodified upstream timm checkpoint.
+
+## Preprocessing
+
+For the model tensor itself:
+
+1. Convert the image to RGB.
+2. Resize it with preserved aspect ratio to fit within `256 × 384`, using
+   bicubic interpolation when enlarging and area interpolation when reducing.
+3. Center-pad it to `256 × 384` with RGB value `(127, 127, 127)`.
+4. Rescale unsigned 8-bit pixels by `1 / 255`.
+5. Normalize each channel with mean `0.5` and standard deviation `0.5`.
+6. Convert from HWC to NCHW layout and add the batch dimension.
+
+The source data pipeline first detects the largest person with YOLO and crops
+to that bounding box. Inputs that are already tightly person-centered are
+closest to the training distribution. Person detection is not part of the
+published classifier and is unnecessary when the input is already cropped.
+
+## ONNX inference
+
+Install `huggingface_hub`, `onnxruntime`, `numpy`, `opencv-python-headless`, and
+`Pillow`, then run:
+
+```python
+from huggingface_hub import hf_hub_download
+import cv2
+import numpy as np
+import onnxruntime as ort
+from PIL import Image, ImageOps
+
+REPO_ID = "electblake/clothing_type_classifier"
+LABELS = ["denim_shorts", "lingerie", "swim_bikini"]
+HEIGHT = 384
+WIDTH = 256
+
+model_path = hf_hub_download(
+    REPO_ID,
+    "clothing_type-tf_efficientnetv2_s.in21k_ft_in1k.onnx",
+)
+
+image = ImageOps.exif_transpose(Image.open("person.jpg")).convert("RGB")
+image = np.asarray(image)
+scale = min(HEIGHT / image.shape[0], WIDTH / image.shape[1])
+resized_width = round(image.shape[1] * scale)
+resized_height = round(image.shape[0] * scale)
+interpolation = cv2.INTER_AREA if scale < 1 else cv2.INTER_CUBIC
+image = cv2.resize(image, (resized_width, resized_height), interpolation=interpolation)
+
+canvas = np.full((HEIGHT, WIDTH, 3), 127, dtype=np.uint8)
+top = (HEIGHT - resized_height) // 2
+left = (WIDTH - resized_width) // 2
+canvas[top : top + resized_height, left : left + resized_width] = image
+
+image = canvas.astype(np.float32) / 255.0
+image = (image - 0.5) / 0.5
+image = np.transpose(image, (2, 0, 1))[None, ...]
+
+session = ort.InferenceSession(model_path, providers=["CPUExecutionProvider"])
+logits = session.run(["logits"], {"image": image})[0][0]
+probabilities = np.exp(logits - logits.max())
+probabilities /= probabilities.sum()
+
+prediction = int(probabilities.argmax())
+print(LABELS[prediction], float(probabilities[prediction]))
+```
+
+## Safetensors inference
+
+From a checkout of the source repository:
+
+```python
+from huggingface_hub import hf_hub_download
+from safetensors.torch import load_file
+
+from src.model import EfficientNetClassifier
+
+weights_path = hf_hub_download(
+    "electblake/clothing_type_classifier",
+    "clothing_type-tf_efficientnetv2_s.in21k_ft_in1k.safetensors",
+)
+model = EfficientNetClassifier(
+    model_name="tf_efficientnetv2_s.in21k_ft_in1k",
+    num_classes=3,
+    dropout=0.15,
+    pretrained=False,
+)
+model.load_state_dict(load_file(weights_path))
+model.eval()
+```
+
+## Training and evaluation
+
+The published checkpoint was selected at epoch 29 with **94.84% validation
+accuracy**. This value comes from the checkpoint metadata and is a
+model-selection result on the project's validation split, not an independent
+benchmark or test-set result.
+
+Training used weighted cross-entropy, AdamW, MixUp, CutMix, horizontal flips,
+geometric transforms, brightness and contrast changes, and hue and saturation
+changes. The backbone was initially frozen and then fully fine-tuned.
+
+## Intended use and limitations
+
+The model is intended for research, media organization, and non-critical
+clothing-type tagging. It is not intended for decisions affecting a person's
+rights or access to services.
+
+Performance is expected to vary with occlusion, multiple people, unusual
+framing, small subjects, lighting, image quality, and clothing outside the
+three published categories. The classifier always selects one of its three
+known labels and has no `other` or rejection class. Confidence scores are
+softmax probabilities and have not been calibrated.

config.json

@@ -0,0 +1,50 @@
+{
+  "architecture": "tf_efficientnetv2_s",
+  "num_classes": 3,
+  "num_features": 1280,
+  "id2label": {
+    "0": "denim_shorts",
+    "1": "lingerie",
+    "2": "swim_bikini"
+  },
+  "label2id": {
+    "denim_shorts": 0,
+    "lingerie": 1,
+    "swim_bikini": 2
+  },
+  "pretrained_cfg": {
+    "tag": "in21k_ft_in1k",
+    "custom_load": false,
+    "input_size": [
+      3,
+      384,
+      256
+    ],
+    "fixed_input_size": true,
+    "interpolation": "bicubic",
+    "resize_mode": "longest_max_size",
+    "padding": "center",
+    "pad_value": [
+      127,
+      127,
+      127
+    ],
+    "mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "std": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "num_classes": 3,
+    "pool_size": [
+      12,
+      8
+    ],
+    "first_conv": "conv_stem",
+    "classifier": "classifier"
+  }
+}

preprocessor_config.json

@@ -0,0 +1,28 @@
+{
+  "architecture": "tf_efficientnetv2_s",
+  "data_config": {
+    "input_size": [
+      3,
+      384,
+      256
+    ],
+    "interpolation": "bicubic",
+    "mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "std": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "resize_mode": "longest_max_size",
+    "padding": "center",
+    "pad_value": [
+      127,
+      127,
+      127
+    ]
+  }
+}