|
--- |
|
license: apache-2.0 |
|
tags: |
|
- generated_from_trainer |
|
metrics: |
|
- accuracy |
|
model-index: |
|
- name: beit-sketch-classifier |
|
results: [] |
|
--- |
|
|
|
<!-- This model card has been generated automatically according to the information the Trainer had access to. You |
|
should probably proofread and complete it, then remove this comment. --> |
|
|
|
# beit-sketch-classifier |
|
|
|
This model is a version of [microsoft/beit-base-patch16-224-pt22k-ft22k](https://huggingface.co/microsoft/beit-base-patch16-224-pt22k-ft22k) fine-tuned on a dataset of Quick!Draw! sketches (~10% of [QuickDraw's 50M sketches](https://huggingface.co/datasets/kmewhort/quickdraw-bins-50M)). |
|
It achieves the following results on the evaluation set: |
|
- Loss: 0.7372 |
|
- Accuracy: 0.8098 |
|
|
|
## Intended uses & limitations |
|
|
|
It's intended to be used to classifier sketches with a line-segment input format (there's no data augmentation in the fine-tuning; the input raster images ideally need to be generated from line-vector format very similarly to the training images). |
|
|
|
You can generate the requisite PIL images from Quickdraw `bin` format with the following: |
|
|
|
``` |
|
# packed bytes -> dict (fro mhttps://github.com/googlecreativelab/quickdraw-dataset/blob/master/examples/binary_file_parser.py) |
|
def unpack_drawing(file_handle): |
|
key_id, = unpack('Q', file_handle.read(8)) |
|
country_code, = unpack('2s', file_handle.read(2)) |
|
recognized, = unpack('b', file_handle.read(1)) |
|
timestamp, = unpack('I', file_handle.read(4)) |
|
n_strokes, = unpack('H', file_handle.read(2)) |
|
image = [] |
|
n_bytes = 17 |
|
for i in range(n_strokes): |
|
n_points, = unpack('H', file_handle.read(2)) |
|
fmt = str(n_points) + 'B' |
|
x = unpack(fmt, file_handle.read(n_points)) |
|
y = unpack(fmt, file_handle.read(n_points)) |
|
image.append((x, y)) |
|
n_bytes += 2 + 2*n_points |
|
result = { |
|
'key_id': key_id, |
|
'country_code': country_code, |
|
'recognized': recognized, |
|
'timestamp': timestamp, |
|
'image': image, |
|
} |
|
return result |
|
|
|
# packed bin -> RGB PIL |
|
def binToPIL(packed_drawing): |
|
padding = 8 |
|
radius = 7 |
|
scale = (224.0-(2*padding)) / 256 |
|
|
|
unpacked = unpack_drawing(io.BytesIO(packed_drawing)) |
|
unpacked_image = unpacked['image'] |
|
image = np.full((224,224), 255, np.uint8) |
|
for stroke in unpacked['image']: |
|
prevX = round(stroke[0][0]*scale) |
|
prevY = round(stroke[1][0]*scale) |
|
for i in range(1, len(stroke[0])): |
|
x = round(stroke[0][i]*scale) |
|
y = round(stroke[1][i]*scale) |
|
cv2.line(image, (padding+prevX, padding+prevY), (padding+x, padding+y), 0, radius, -1) |
|
prevX = x |
|
prevY = y |
|
pilImage = Image.fromarray(image).convert("RGB") |
|
return pilImage |
|
``` |
|
|
|
## Training procedure |
|
|
|
### Training hyperparameters |
|
|
|
The following hyperparameters were used during training: |
|
- learning_rate: 5e-05 |
|
- train_batch_size: 64 |
|
- eval_batch_size: 64 |
|
- seed: 42 |
|
- gradient_accumulation_steps: 4 |
|
- total_train_batch_size: 256 |
|
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 |
|
- lr_scheduler_type: linear |
|
- lr_scheduler_warmup_ratio: 0.1 |
|
- num_epochs: 3 |
|
|
|
### Training results |
|
|
|
| Training Loss | Epoch | Step | Accuracy | Validation Loss | |
|
|:-------------:|:-----:|:-----:|:--------:|:---------------:| |
|
| 0.939 | 1.0 | 12606 | 0.7853 | 0.8275 | |
|
| 0.7312 | 2.0 | 25212 | 0.7587 | 0.8027 | |
|
| 0.6174 | 3.0 | 37818 | 0.7372 | 0.8098 | |
|
|
|
|
|
### Framework versions |
|
|
|
- Transformers 4.25.1 |
|
- Pytorch 1.13.1+cu117 |
|
- Datasets 2.7.1 |
|
- Tokenizers 0.13.2 |
|
|
