sivan22

/

ResNet-finetuned-HHD

like 0

מצאתי את הקוד ששימש לאימון:

from datasets import load_dataset
from transformers import AutoFeatureExtractor, ResNetForImageClassification, AutoImageProcessor
import torch
import numpy as np
from torchvision.transforms import *
from PIL import Image, ImageOps
from transformers import DefaultDataCollator
import evaluate
from transformers import  TrainingArguments, Trainer

dataset = load_dataset('sivan22/hebrew-handwritten-characters')

labels = dataset["train"].features["label"].names
label2id, id2label = dict(), dict()
for i, label in enumerate(labels):
    label2id[label] = str(i)
    id2label[str(i)] = label

checkpoint = "microsoft/resnet-18"
feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/resnet-18")
model = ResNetForImageClassification.from_pretrained(checkpoint,num_labels=len(labels),
    id2label=id2label,
    label2id=label2id,
    ignore_mismatched_sizes=True)


def resize_and_pad (im, desired_size = 224):

    old_size = im.size  # old_size[0] is in (width, height) format

    ratio = float(desired_size)/max(old_size)
    new_size = tuple([int(x*ratio) for x in old_size])
# use thumbnail() or resize() method to resize the input image

# thumbnail is a in-place operation

# im.thumbnail(new_size, Image.ANTIALIAS)

    im = im.resize(new_size, Image.ANTIALIAS)
# create a new image and paste the resized on it

    new_im = Image.new("RGB", (desired_size, desired_size),color = (255, 255, 255))
    new_im.paste(im, ((desired_size-new_size[0])//2,
                    (desired_size-new_size[1])//2))
    return new_im




normalize = Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std)
randAug = RandAugment(6,1)

_transforms = Compose((randAug, resize_and_pad, ToTensor(), normalize) )

def transforms(examples):
    examples["pixel_values"] = [_transforms(image) for image in examples["image"]] 
    del examples["image"]
    return examples

dataset1= dataset.with_transform(transforms)

accuracy = evaluate.load("accuracy")

def compute_metrics(eval_pred):
    predictions, labels = eval_pred
    predictions = np.argmax(predictions, axis=1)
    return accuracy.compute(predictions=predictions, references=labels)


data_collator = DefaultDataCollator()

training_args = TrainingArguments(
    output_dir="hhd_ResNet",
    remove_unused_columns=False,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    learning_rate=5e-5,
    per_device_train_batch_size=32,
    gradient_accumulation_steps=4,
    per_device_eval_batch_size=32,
    num_train_epochs=10,
    #warmup_ratio=0.1,
    logging_steps=10,
    load_best_model_at_end=True,
    metric_for_best_model="accuracy",
    push_to_hub=False,
)


trainer = Trainer(
    model=model,
    args=training_args,
    data_collator=data_collator,
    train_dataset=dataset1["train"],
    eval_dataset=dataset1["test"],
    compute_metrics=compute_metrics,         
)

trainer.train()

אני פשוט צריכה להוסיף לספר פרויקט את הקוד ממש של המודל, של השכבות שלו וכו
אגב זה מודל שמזהה אותיות ולא מילים, נכון?

import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(28 * 28, 128)
        self.fc2 = nn.Linear(128, 128)
        self.fc3 = nn.Linear(128, 64)
        self.fc4 = nn.Linear(64, 28)

    def forward(self, x):
        x = torch.flatten(x, 1) # flatten all dimensions except batch
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.relu(self.fc3(x))
        x = self.fc4(x)
        return x


net = Net()