Request for Updated Pre-trained Models about deep-text-recognition-benchmark HOT 11 OPEN

import os
from train import train
from model import Model
from PIL import Image
from utils import CTCLabelConverter, AttnLabelConverter
import torchvision.transforms as transforms
import pandas as pd
import torch
from ddevice import device
from dataset import NormalizePAD, ResizeNormalize, adjust_contrast_grey
import math
import numpy as np
from get_config import get_config

opt = get_config("config_files/en_chords_synth_config.yaml")

class PredictAlignCollate(object):

    def __init__(self, imgH=32, imgW=100, keep_ratio_with_pad=False, contrast_adjust = 0.):
        self.imgH = imgH
        self.imgW = imgW
        self.keep_ratio_with_pad = keep_ratio_with_pad
        self.contrast_adjust = contrast_adjust

    def __call__(self, image):
        image = np.array(image)
        if self.keep_ratio_with_pad:  # same concept with 'Rosetta' paper
            resized_max_w = self.imgW
            input_channel = 1
            transform = NormalizePAD((input_channel, self.imgH, resized_max_w))
            h, w = image.shape[:2]

            #### augmentation here - change contrast
            if self.contrast_adjust > 0:
                image = np.array(image.convert("L"))
                image = adjust_contrast_grey(image, target = self.contrast_adjust)
                image = Image.fromarray(image, 'L')

            ratio = w / float(h)
            if math.ceil(self.imgH * ratio) > self.imgW:
                resized_w = self.imgW
            else:
                resized_w = math.ceil(self.imgH * ratio)

            image = Image.fromarray(image, 'L')
            resized_image = image.resize((resized_w, self.imgH), Image.BICUBIC)
            import uuid
            # resized_image.save(f"temp/{uuid.uuid4()}.jpg")
            return resized_image
        else:
            transform = ResizeNormalize((self.imgW, self.imgH))
            resized_image = transform(resized_image)
            return resized_image

def predict(opt, image_path, model_path, text_for_pred):
    """ Predict text from a single image """
    image = Image.open(image_path).convert('L')
    transform = transforms.Compose([
        PredictAlignCollate(imgH=opt.imgH, imgW=opt.imgW, keep_ratio_with_pad=opt.PAD, contrast_adjust = opt.contrast_adjust),
        transforms.ToTensor(),
        transforms.Normalize((0.5,), (0.5,)),
    ])
    image = transform(image).unsqueeze(0).to(device)
    converter = CTCLabelConverter(opt.character)
    opt.num_class = len(converter.character)
    with torch.no_grad():
        model = Model(opt)
        model = torch.nn.DataParallel(model).to(device)
        model.load_state_dict(torch.load(model_path, map_location=device))
        model.eval()
        preds = model(image, text_for_pred, is_train=False)
        preds_size = torch.IntTensor([preds.size(1)])
        _, preds_index = preds.max(2)
        preds_index = preds_index.view(-1)
        preds_str = converter.decode_greedy(preds_index.data, preds_size.data)
        return preds_str[0]

root  = os.path.dirname(os.path.abspath(__file__))
pathi = os.path.join(root, "dataset_structure", "validation_book")
# pathi = os.path.join(root, "jazz_book_dataset", "transformed")
# pathi = "/Users/carlosazuaje/Charlyjazz/Github/OCR-Chord-Notation/synthetic_dataset_chords_v2/batch_1"
files = os.listdir(pathi)

if __name__ == "__main__":
    for filename in files:
        if not filename.endswith('.jpg'):
            continue
        file_path = os.path.join(pathi, filename)
        label = (file_path.split('/')[-1])
        prediction = predict(
            opt, 
            file_path, 
            "/Users/carlosazuaje/Charlyjazz/Github/OCR-Chord-Notation/saved_models/chords_5millions/saved_models_chords_5millions_iter_949999.pth",
            label)
        print(f'Label: {label} Prediction: {prediction}')