print("CUDA will be used")
else:
print("CUDA won't be used")
data_path = sys.argv[1]
models_rep = sys.argv[2]
BATCH_SIZE = 100
HEIGHT = 80
WIDTH = 80
print(f"Loading dataset from {data_path}...")
ds = CustomDataSetSimple(nb_digit=5, nb_samples=100)
print(f"...dataset loaded")
dataloader = DataLoader(ds, batch_size=BATCH_SIZE, shuffle=False)
model = to_best_device(SimpleModel())
do_load_model(models_rep, model, exit_on_error=True)
model.eval()
start = time.time()
results = []
def from_target_labels(target: torch.Tensor) -> str:
"""
:param target: tensor of shape (n) with n being the length of the sequence
and each element containing the index of one of the character
:return: a trimmed string containing only relevant characters
"""
selected_values = losses[-val_patience:]
idx_min = selected_values.index(min(selected_values))
return idx_min < (val_patience / 2 - 1)
else:
return False
print(f"Loading dataset ...")
ds = CustomRawDataSet(root_dir=data_path)
len_train = int(len(ds) * 0.8)
train_set, val_set = torch.utils.data.random_split(ds, [len_train, len(ds) - len_train])
#imshow(train_set[5][0])
#exit()
print(f"...dataset loaded")
dataloader = DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True)
dataloader_val = DataLoader(val_set, batch_size=BATCH_SIZE, shuffle=False)
model = to_best_device(CRNN())
best_model = to_best_device(CRNN())
if load_model:
if not do_load_model(models_rep, model):
model.initialize_weights()
else:
if not os.path.exists(models_rep):
os.makedirs(models_rep)
model.initialize_weights()
model.train()
loss = to_best_device(nn.CTCLoss(blank=0, zero_infinity=True, reduction="mean"))
#optimizer = torch.optim.AdamW(model.parameters(), lr=LEARNING_RATE)
#scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', cooldown=0, verbose=True, patience=10)
print("CUDA won't be used")
data_path = sys.argv[1]
models_rep = sys.argv[2]
MAX_SENTENCE_LENGTH = int(sys.argv[3])
BATCH_SIZE = 100
HEIGHT = 80
WIDTH = 80
print(f"Loading dataset from {data_path}...")
ds = CustomDataSetSimple(nb_digit=MAX_SENTENCE_LENGTH, nb_samples=100)
print(f"...dataset loaded")
dataloader = DataLoader(ds, batch_size=BATCH_SIZE, shuffle=False)
model = to_best_device(MultiMdlstm(height=10, width=MAX_SENTENCE_LENGTH, nb_classes=11))
do_load_model(models_rep, model, exit_on_error=True)
model.eval()
start = time.time()
results = []
def from_target_labels(target: torch.Tensor) -> str:
"""
:param target: tensor of shape (n) with n being the length of the sequence
and each element containing the index of one of the character
:return: a trimmed string containing only relevant characters
"""
else:
print("CUDA won't be used")
args = parse_args()
data_path = args.data_path
models_rep = args.models_path
BATCH_SIZE = int(args.batch)
MAX_SENTENCE_LENGTH = int(args.sentence)
print(f"Loading dataset from {data_path}...")
ds = CustomRawDataSet(root_dir=data_path)
print(f"...dataset loaded")
dataloader = DataLoader(ds, batch_size=BATCH_SIZE, shuffle=False)
model = to_best_device(CRNN())
do_load_model(models_rep, model, exit_on_error=True)
model.eval()
start = time.time()
results = []
def from_predicted_labels(predicted: torch.Tensor) -> str:
"""
:param predicted: tensor of shape (L, X) with :
- L being the length of the sequence
- X being the size of the list of known characters
and each element containing the index of one of the character
def imshow(inp):
inp = inp.numpy()[0]
mean = 0.1307
std = 0.3081
inp = ((mean * inp) + std)
plt.imshow(inp, cmap='gray')
plt.show()
print(f"Loading dataset ...")
ds = CustomDataSetSimple(nb_digit=MAX_SENTENCE_LENGTH, nb_samples=1000)
#imshow(ds[5][0])
#exit()
print(f"...dataset loaded")
dataloader = DataLoader(ds, batch_size=int(len(ds) / 3), shuffle=True)
model = to_best_device(MultiMdlstm(height=10, width=MAX_SENTENCE_LENGTH, nb_classes=11))
best_model = to_best_device(MultiMdlstm(height=10, width=MAX_SENTENCE_LENGTH, nb_classes=11))
if load_model:
if not do_load_model(models_rep, model):
model.initialize_weights()
else:
model.initialize_weights()
model.train()
loss = to_best_device(nn.CTCLoss(blank=10, zero_infinity=True, reduction="sum"))
optimizer = torch.optim.AdamW(model.parameters(), lr=LEARNING_RATE)
scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer,
max_lr=MAX_LR,
steps_per_epoch=int(len(dataloader)),
def imshow(inp):
inp = inp.numpy()[0]
mean = 0.1307
std = 0.3081
inp = ((mean * inp) + std)
plt.imshow(inp, cmap='gray')
plt.show()
print(f"Loading dataset from {data_path}...")
ds = get_dataset(data_path, width=WIDTH, height=HEIGHT, target_length=MAX_SENTENCE_LENGTH)
#imshow(ds[5][0])
#exit()
print(f"...dataset loaded")
dataloader = DataLoader(ds, batch_size=int(len(ds) / 3), shuffle=True)
model = to_best_device(ParagraphReader(height=HEIGHT, width=WIDTH, nb_layers=3, feature_maps_multiplicity=features_multiplicity))
best_model = to_best_device(ParagraphReader(height=HEIGHT, width=WIDTH, nb_layers=3, feature_maps_multiplicity=features_multiplicity))
if load_model:
if not do_load_model(models_rep, model):
model.initialize_weights()
else:
model.initialize_weights()
model.train()
loss = to_best_device(nn.CTCLoss(blank=blank_id, zero_infinity=True, reduction="sum"))
optimizer = torch.optim.AdamW(model.parameters(), lr=LEARNING_RATE)
scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer,
max_lr=MAX_LR,
steps_per_epoch=int(len(dataloader)),
def imshow(inp):
inp = inp.numpy()[0]
mean = 0.1307
std = 0.3081
inp = ((mean * inp) + std)
plt.imshow(inp, cmap='gray')
plt.show()
print(f"Loading dataset ...")
ds = CustomDataSetSimple(nb_digit=MAX_SENTENCE_LENGTH, nb_samples=1000)
#imshow(ds[5][0])
#exit()
print(f"...dataset loaded")
dataloader = DataLoader(ds, batch_size=int(len(ds) / 3), shuffle=True)
model = to_best_device(SimpleModel())
best_model = to_best_device(SimpleModel())
if load_model:
if not do_load_model(models_rep, model):
model.initialize_weights()
else:
model.initialize_weights()
model.train()
loss = to_best_device(nn.CTCLoss(blank=10, zero_infinity=True,
reduction="sum"))
optimizer = torch.optim.AdamW(model.parameters(), lr=LEARNING_RATE)
scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer,
max_lr=MAX_LR,
steps_per_epoch=int(
BATCH_SIZE = 100
HEIGHT = 40
WIDTH = 80
MAX_SENTENCE_LENGTH = int(sys.argv[3])
features_multiplicity = int(sys.argv[4])
print(f"Loading dataset from {data_path}...")
ds = get_dataset(data_path,
width=WIDTH,
height=HEIGHT,
target_length=MAX_SENTENCE_LENGTH)
print(f"...dataset loaded")
dataloader = DataLoader(ds, batch_size=BATCH_SIZE, shuffle=False)
model = to_best_device(
ParagraphReader(height=HEIGHT,
width=WIDTH,
nb_layers=3,
feature_maps_multiplicity=features_multiplicity))
do_load_model(models_rep, model, exit_on_error=True)
model.eval()
start = time.time()
results = []
def from_target_labels(target: torch.Tensor) -> str:
"""
:param target: tensor of shape (n) with n being the length of the sequence
and each element containing the index of one of the character
