def run_training():
image_files = glob.glob(os.path.join(config.DATA_DIR, "*.png"))[:10]
target_orig = [x.split('/')[-1][:-4] for x in image_files]
targets = [[c for c in x] for x in target_orig]
targets_flat = [c for clist in targets for c in clist]
lbl_enc = preprocessing.LabelEncoder()
lbl_enc.fit(targets_flat)
targets_enc = [lbl_enc.transform(x) for x in targets]
# didn't get this
targets_enc = np.array(targets_enc) + 1
# print(targets_enc)
# print(len(lbl_enc.classes_))
train_imgs, test_imgs, train_targets, test_targets, train_orig_targets, test_orig_targets = model_selection.train_test_split(
image_files, targets_enc, target_orig, test_size=0.1, random_state=42)
train_dataset = dataset.ClassificationDataset(image_paths=train_imgs,
targets=train_targets,
resize=(config.IMAGE_HEIGHT,
config.IMAGE_WIDTH))
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=True)
test_dataset = dataset.ClassificationDataset(image_paths=test_imgs,
targets=test_targets,
resize=(config.IMAGE_HEIGHT,
config.IMAGE_WIDTH))
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=False)
model = CaptchModel(num_chars=len(lbl_enc.classes_))
model.to(config.DEVICE)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
factor=0.8,
patience=5,
verbose=True)
for epoch in range(config.EPOCHS):
train_loss = engine.train_fn(model, train_loader, optimizer)
valid_preds, valid_loss = engine.eval_fn(model, test_loader)
valid_cap_preds = []
for vp in valid_preds:
current_preds = decode_predictions(vp, lbl_enc)
valid_cap_preds.extend(current_preds)
pprint(list(zip(test_orig_targets, valid_cap_preds)))
print(
f"Epoch = {epoch}, TrainLoss = {train_loss}, ValidLoss = {valid_loss}"
)
def get_pred(self, img_bytes):
# img = Image.open("../input/mca_test_files/3487.png", mode='r')
# imgByteArr = io.BytesIO()
# img.save(imgByteArr, format='PNG')
# imgByteArr = imgByteArr.getvalue()
image = (Image.open(io.BytesIO(img_bytes)).convert("RGB"), )
test_dataset = dataset.ClassificationDataset(
image_paths=image,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH),
)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=False,
)
lbl_enc = joblib.load("../input/pickles/lbl_encoder.pkl")
model = CaptchaModel(lbl_enc.classes_)
model.load_state_dict(torch.load("../input/pickles/captcha.pth"))
test_preds = []
for data in test_loader:
model.eval()
batch_preds, _ = model(**data)
test_preds.append(batch_preds)
all_preds = []
for test_data in test_preds:
current_preds = self.decode_predictions(test_data, lbl_enc)
for i in current_preds:
all_preds.append(i)
print(all_preds[0])
def evaluate():
files = []
for img_ext in config.ALLOWED_EXTENSIONS:
files.extend(
glob(
os.path.join(config.IMAGES_UPLOADED_PATH,
"*.{}".format(img_ext))))
files.sort(key=os.path.getctime, reverse=True)
test_img = files[:1]
test_dataset = dataset.ClassificationDataset(image_paths=test_img,
resize=(config.IMAGE_HEIGHT,
config.IMAGE_WIDTH))
test_loader = DataLoader(
test_dataset,
batch_size=1,
num_workers=0,
)
model = CaptchaModel(num_chars=len(lbl_enc.classes_))
model.to(config.DEVICE)
model.load_state_dict(
load('./checkpoints/captcha_v1/captcha_v1.pth',
map_location=config.DEVICE))
model.eval()
for data in test_loader:
data["images"] = data["images"].to(config.DEVICE)
prediction, _ = model(data["images"])
prediction_output = decode_predictions(prediction, lbl_enc)
return prediction_output
def get_dataloader_test(args, root, image_list):
kwargs = {'num_workers': args.num_workers, 'pin_memory': args.pin_memory}
if (args.architecture in ['resnet_i48_18']):
dataset = ds.ClassificationDataset(root,
image_list,
transform=transforms.Compose([
transforms.Resize(60),
transforms.CenterCrop(48),
transforms.ToTensor(),
transforms.Normalize((0.5, ),
(0.28, ))
]),
is_grey=False)
elif (args.architecture in ['resnet_i24_34']):
dataset = ds.ClassificationDataset(
root,
image_list,
transform=transforms.Compose([
transforms.Resize(28),
transforms.CenterCrop(24),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
]),
is_grey=False)
else:
dataset = ds.ClassificationDataset(
root,
image_list,
transform=transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
]))
loader = DataLoader(dataset,
batch_size=args.batch_size // 3,
shuffle=False,
**kwargs)
return loader
def run_training():
transform = transforms.Compose([
transforms.Resize(size=(32,32)),
transforms.ToTensor(),
transforms.Normalize((0.45820624,0.43722707,0.39191988),(0.23130463,0.22692703,0.22379072))
])
label_encoder = preprocessing.LabelEncoder()
image_paths = glob.glob(os.path.join(config.DATA_DIR,"**/*.*"),recursive=True)
targets = [x.split("/")[-2] for x in image_paths]
label_encoded = np.array(label_encoder.fit_transform(targets))
(train_images,test_images,train_labels,test_labels) = model_selection.train_test_split(image_paths,label_encoded,test_size=0.2,random_state=0)
# print(len(train_images))
# print(len(train_labels))
train_dataset = dataset.ClassificationDataset(train_images,train_labels,transform)
train_loader = torch.utils.data.DataLoader(train_dataset,batch_size=config.BATCH_SIZE,shuffle=True)
test_dataset = dataset.ClassificationDataset(test_images,test_labels,transform)
test_loader = torch.utils.data.DataLoader(test_dataset,batch_size=config.BATCH_SIZE,shuffle=False)
model =SmallNet(num_classes=3)
model.to(config.DEVICE)
opt = torch.optim.Adam(model.parameters(),lr=3e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
opt, factor=0.8, patience=5, verbose=True
)
for epoch in range(config.EPOCHS):
train_loss = engine.train_fn(model,train_loader,opt)
val_accuracy,val_loss = engine.eval_fn(model,test_loader)
print(
f"Epoch={epoch}, Train Loss={train_loss}, Test Loss={val_loss} Accuracy={val_accuracy}"
)
scheduler.step(val_loss)
print("Saved model...")
torch.save(model.state_dict(),"./models/weights_latest.pt")
def run_training():
image_files = glob.glob(os.path.join(config.DATA_DIR,"*.png"))
# path to the dataset
targets_orig = [x.split('/')[-1][:-4] for x in image_files]
targets = [[c for c in x] for x in targets_orig]
targets_flat = [c for clist in targets for c in clist]
lbl_enc = preprocessing.LabelEncoder()
lbl_enc.fit(targets_flat)
targets_enc = [lbl_enc.transform(x) for x in targets]
targets_enc = np.array(targets_enc) + 1
# print(targets)
# print(target_enc)
# print(len(lbl_enc.classes_))
# # print(targets_orig)
# for i, item in enumerate(lbl_enc.classes_):
# print(item, '-->', i)
train_imgs, test_imgs, train_targets, test_targets, train_orig_targets, test_orig_targets= model_selection.train_test_split(image_files, targets_enc, targets_orig, test_size = 0.1, random_state= 42)
train_dataset = dataset.ClassificationDataset(image_paths = train_imgs, targets = train_targets, resize = (config.IMAGE_HEIGHT, config.IMAGE_WIDTH))
print(train_dataset[0])
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size = config.BATCH_SIZE,
num_workers = config.NUM_WORKERS,
shuffle = True
)
test_dataset = dataset.ClassificationDataset(image_paths = test_imgs, targets = test_targets, resize = (config.IMAGE_HEIGHT, config.IMAGE_WIDTH))
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size = config.BATCH_SIZE,
num_workers = config.NUM_WORKERS,
shuffle = False
)
model = CaptchaModel(num_chars = len(lbl_enc.classes_))
model.to(config.DEVICE)
optimizer = torch.optim.Adam(model.parameters(), lr = 3e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor =0.8, patience= 5, verbose= True)
for epoch in range(config.EPOCHS):
train_loss = engine.train_fn(model, train_loader, optimizer)
valid_pred, valid_loss = engine.eval_fn(model, train_loader)
def pred_captcha(img_bytes):
image = Image.open(img_bytes).convert("RGB") #change accordingly
test_dataset = dataset.ClassificationDataset(
image_paths=image,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH),
)
trainer = pl.Trainer(max_epochs=200)
model = CaptchaModel(
num_classes=len(lbl_encoder.classes_),
test_dataset=test_dataset,
lbl_encoder=lbl_encoder,
)
model.load_state_dict(
torch.load(model_chkpoint,
map_location=torch.device('cpu'))['state_dict'])
trainer.test(model)
fin_res = model.return_final_output()
print(fin_res)
def get_dataloader_test(args, root, image_list):
kwargs = {'num_workers': args.num_workers, 'pin_memory': args.pin_memory}
dataset = ds.ClassificationDataset(
root,
image_list,
transform=transforms.Compose([
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]))
loader = DataLoader(dataset,
batch_size=args.batch_size // 3,
shuffle=False,
**kwargs)
return loader
def get_dataloader_train(args, root, image_list):
# kwargs = {'num_workers': 4, 'pin_memory': True} if args.cuda else {}
kwargs = {'num_workers': args.num_workers, 'pin_memory': args.pin_memory}
dataset = ds.ClassificationDataset(
root,
image_list,
transform=transforms.Compose([
transforms.RandomRotation(3),
# transforms.RandomCrop(224),
transforms.RandomResizedCrop(224,
scale=(0.74, 0.90),
ratio=(0.9, 1.0)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
)
# # Balancing the classes !!!!!!
# prob = np.zeros(args.num_classes)
# for i in range(len(dataset)):
# cur_class = dataset[i][1]
# prob[cur_class]+=1
# prob = 1.0 / prob
#
#
# reciprocal_weights = np.zeros(len(dataset))
# epoch_length = args.epoch_length
# for i in range(len(dataset)):
# _, label = dataset[i]
# reciprocal_weights[i] = prob[label]
# weights = torch.from_numpy(reciprocal_weights)
#
#
# weighted_sampler = sampler.WeightedRandomSampler(weights , epoch_length)
# loader = DataLoader(dataset, batch_size=args.batch_size,
# sampler=weighted_sampler, **kwargs)
loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True)
return loader
def run_test(u, v):
image_files = sorted(
glob.glob(
"../input/all_captcha_types/mca_captcha/test_images/*.png"))[u:v]
print(image_files[:5])
test_dataset = dataset.ClassificationDataset(
image_paths=image_files,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH),
)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=False,
)
lbl_enc = joblib.load(
"../input/pickles/tan_pan_oltas_gst_epfo_rc_lbl_encoder.pkl")
model = CaptchaModel(len(lbl_enc.classes_))
model.load_state_dict(
torch.load("../src/lightning_logs/version_3/checkpoints/epoch=86.ckpt")
["state_dict"])
test_preds = []
for data in test_loader:
model.eval()
batch_preds, _ = model(**data)
test_preds.append(batch_preds)
all_preds = []
for test_data in test_preds:
current_preds = decode_predictions(test_data, lbl_enc)
for i in current_preds:
all_preds.append(i)
print(all_preds)
return all_preds
def run_training():
image_files = glob.glob(os.path.join(config.DATA_DIR, "*.png"))
image_files = image_files[:10]
print(f"Number of Images Found: {len(image_files)}")
# "../xywz.png" -> "xywz"
targets_orig = [x.split("/")[-1].split(".")[0] for x in image_files]
# separate the targets on character level
targets = [[char for char in x] for x in targets_orig]
targets_flat = [c for clist in targets for c in clist]
lbl_encoder = preprocessing.LabelEncoder()
lbl_encoder.fit(targets_flat)
targets_enc = [lbl_encoder.transform(x) for x in targets]
# label encodes from 0, so add 1 to start from 1: 0 will be saved for unknown
targets_enc = np.array(targets_enc) + 1
print(f"Number of Unique Classes: {len(lbl_encoder.classes_)}")
train_imgs, test_imgs, train_targets, test_targets, train_orig_targets, test_orig_targets = \
model_selection.train_test_split(image_files, targets_enc, targets_orig, test_size=0.1, random_state=42)
train_dataset = dataset.ClassificationDataset(image_paths=train_imgs,
targets=train_targets,
resize=(config.IMAGE_HEIGHT,
config.IMAGE_WIDTH))
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=True)
test_dataset = dataset.ClassificationDataset(image_paths=test_imgs,
targets=test_targets,
resize=(config.IMAGE_HEIGHT,
config.IMAGE_WIDTH))
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=False)
model = CaptchaModel(num_chars=len(lbl_encoder.classes_))
model.to(config.DEVICE)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
factor=0.8,
patience=5,
verbose=True)
train_loss_data = []
test_loss_data = []
for epoch in range(config.EPOCHS):
train_loss = engine.train_fn(model,
train_loader,
optimizer,
save_model=True)
eval_preds, test_loss = engine.eval_fn(model, test_loader)
eval_captcha_preds = []
for vp in eval_preds:
current_preds = decode_predictions(vp, lbl_encoder)
eval_captcha_preds.extend(current_preds)
combined = list(zip(test_orig_targets, eval_captcha_preds))
pprint(combined[:10])
test_dup_rem = [remove_duplicates(c) for c in test_orig_targets]
accuracy = metrics.accuracy_score(test_dup_rem, eval_captcha_preds)
print(
f"Epoch={epoch}, Train Loss={train_loss}, Test Loss={test_loss} Accuracy={accuracy}"
)
scheduler.step(test_loss)
train_loss_data.append(train_loss)
test_loss_data.append(test_loss)
# print(train_dataset[0])
plot_loss(train_loss_data, test_loss_data, plot_path=config.PLOT_PATH)
print("done")
def run_training():
# image_files
image_files = glob.glob("../input/train_all_captchas/*.png")
print(image_files[:4])
# targets
targets_orig = [i.split("/")[-1][:-4] for i in image_files]
print(targets_orig[:5])
# creating a list of list for the targets
targets = [[j for j in i] for i in targets_orig]
# flattening the lists
targets_flat = [item for sublists in targets for item in sublists]
# print(targets_flat)
lbl_encoder = preprocessing.LabelEncoder()
lbl_encoder.fit(targets_flat)
enc_targets = [lbl_encoder.transform(x) for x in targets]
# this +1 is to add 1 to all the encoded labels, so that we could use 0 for the unknown values
enc_targets = np.array(enc_targets) + 1
print(len(enc_targets))
print(len(lbl_encoder.classes_))
(
train_imgs,
test_imgs,
train_targets_orig,
test_target_orig,
train_targets,
test_targets,
) = model_selection.train_test_split(image_files,
targets_orig,
enc_targets,
test_size=0.1,
random_state=42)
print(len(train_imgs), len(train_targets))
print(len(test_imgs), len(test_targets))
train_dataset = dataset.ClassificationDataset(
image_paths=train_imgs,
targets=train_targets,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH),
)
train_dataloader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=True,
)
test_dataset = dataset.ClassificationDataset(
image_paths=test_imgs,
targets=test_targets,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH),
)
test_dataloader = torch.utils.data.DataLoader(
test_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=False,
)
model = CaptchaModel(num_chars=len(lbl_encoder.classes_))
model.to(config.DEVICE)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
factor=0.8,
patience=5,
verbose=True)
for epoch in range(config.EPOCHS):
train_loss = engine.train(model, train_dataloader, optimizer)
valid_preds, valid_loss = engine.eval(model, test_dataloader)
valid_captcha_preds = []
for vp in valid_preds:
current_preds = decode_predictions(vp, lbl_encoder)
valid_captcha_preds.extend(current_preds)
combined = list(zip(test_target_orig, valid_captcha_preds))
print(combined[:20])
test_dup_rem = [remove_duplicates(c) for c in test_target_orig]
accuracy = metrics.accuracy_score(test_dup_rem, valid_captcha_preds)
print(
f"Epoch={epoch}, Train Loss={train_loss}, Test Loss={valid_loss} Accuracy={accuracy}"
)
scheduler.step(valid_loss)
joblib.dump(
lbl_encoder,
"../input/pickles/tan_pan_oltas_gst_epfo_rc_lbl_encoder.pkl")
torch.save(model.state_dict(),
"../input/pickles/tan_pan_oltas_gst_epfo_rc_model.pth")
test_imgs,
train_targets_orig,
test_target_orig,
train_targets,
test_targets,
) = model_selection.train_test_split(
image_files, targets_orig, enc_targets, test_size=0.1, random_state=42
)
print(len(train_imgs), len(train_targets))
print(len(test_imgs), len(test_targets))
train_dataset = dataset.ClassificationDataset(
image_paths=train_imgs,
targets=train_targets,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH),
)
val_dataset = dataset.ClassificationDataset(
image_paths=test_imgs,
targets=test_targets,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH),
)
test_dataset = dataset.ClassificationDataset(
image_paths=single_test_file,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH),
)
def run_training():
image_files = glob.glob(os.path.join(config.DATA_DIR, "*.png"))
targets_orig = [x.split("\\")[-1][:-4] for x in image_files]
targets = [[y for y in x] for x in targets_orig]
targets_flat = [c for clist in targets for c in clist]
label_enc = preprocessing.LabelEncoder()
label_enc.fit(targets_flat)
targets_enc = [label_enc.transform(x) for x in targets]
targets_enc = np.array(targets_enc) + 1
# print(targets_enc)
# print(label_enc.classes_)
(
train_imgs,
test_imgs,
train_targets,
test_targets,
train_orig_targets,
test_orig_targets,
) = model_selection.train_test_split(image_files,
targets_enc,
targets_orig,
test_size=0.1,
random_state=42)
train_dataset = dataset.ClassificationDataset(
image_paths=train_imgs,
targets=train_targets,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH),
)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=True,
pin_memory=True)
test_dataset = dataset.ClassificationDataset(
image_paths=test_imgs,
targets=test_targets,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH),
)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=False,
pin_memory=True)
model = CaptchaModel(num_chars=len(label_enc.classes_)).cuda()
model.to(torch.device(config.DEVICE))
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
factor=0.8,
patience=5,
verbose=True)
for epoch in range(config.EPOCHS):
train_loss = engine.train_fn(model, train_loader, optimizer)
valid_preds, valid_loss = engine.eval_fn(model, test_loader)
valid_cap_preds = []
for vp in valid_preds:
current_preds = decode_predictions(vp, label_enc)
valid_cap_preds.extend(current_preds)
pprint.pprint(list(zip(test_orig_targets, valid_cap_preds))[:10])
test_dup_rem = [remove_duplicates(c) for c in test_orig_targets]
accuracy = metrics.accuracy_score(test_dup_rem, valid_cap_preds)
print(
f"EPOCH: {epoch}.train_loss:{train_loss},valid_loss:{valid_loss}, Accuracy={accuracy}"
)
scheduler.step(valid_loss)
def get_dataloader_train(args, root, image_list):
# kwargs = {'num_workers': 4, 'pin_memory': True} if args.cuda else {}
kwargs = {'num_workers': args.num_workers, 'pin_memory': args.pin_memory}
if (args.architecture in ['resnet_i48_18']):
dataset = ds.ClassificationDataset(
root,
image_list,
transform=transforms.Compose([
transforms.Resize(60),
transforms.RandomRotation(3),
transforms.RandomCrop(48),
# transforms.RandomResizedCrop(48, scale = (0.72,0.76) , ratio = (1.0,1.0)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.28, ))
]),
is_grey=False)
elif args.architecture in ['resnet_i24_34']:
dataset = ds.ClassificationDataset(
root,
image_list,
transform=transforms.Compose([
transforms.Resize(28),
transforms.RandomRotation(3),
transforms.RandomCrop(24),
# transforms.RandomResizedCrop(48, scale = (0.72,0.76) , ratio = (1.0,1.0)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
]),
is_grey=False)
else:
dataset = ds.ClassificationDataset(
root,
image_list,
transform=transforms.Compose([
transforms.Resize(256),
transforms.RandomRotation(3),
# transforms.RandomCrop(224),
transforms.RandomResizedCrop(224,
scale=(0.74, 0.85),
ratio=(1.0, 1.0)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
]),
)
# Balancing the classes !!!!!!
prob = np.zeros(args.num_classes)
for i in range(len(dataset)):
cur_class = dataset.labels[i]
prob[cur_class] += 1
prob = 1.0 / prob
reciprocal_weights = np.zeros(len(dataset))
epoch_length = args.epoch_length
for i in range(len(dataset)):
label = dataset.labels[i]
reciprocal_weights[i] = prob[label]
weights = torch.from_numpy(reciprocal_weights)
weighted_sampler = sampler.WeightedRandomSampler(weights, epoch_length)
loader = DataLoader(dataset,
batch_size=args.batch_size,
sampler=weighted_sampler,
**kwargs)
# loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True)
return loader
def run_training():
image_files = glob.glob(os.path.join(config.DATA_DIR, "*.png"))
# "/../../azopekr.png"
targets_orig = [x.split("/")[-1][:4] for x in image_files]
# abcde -> [a, b, c, d, e]
"""
targets
['6', 'd', 'm', 'x'],
['c', '7', '5', '3'],
['g', 'g', 'd', '7'],
['x', 'e', 'm', 'y'],
['6', 'g', '4', '5'],
['p', '2', 'x', '7'],
['d', 'y', 'p', '7'],
['6', 'e', 'c', 'b'],
['3', 'm', 'x', 'd'],
['f', 'c', 'm', 'e'],
['8', 'n', '6', '2'],
"""
targets = [[c for c in x] for x in targets_orig]
"""
targets_flat
['e',
'2',
'd',
'6',
'f',
'w',
'3',
'b',
'n',
...
]
"""
targets_flat = [c for clist in targets for c in clist]
lbl_enc = preprocessing.LabelEncoder()
lbl_enc.fit(targets_flat)
targets_enc = [lbl_enc.transform(x) for x in targets]
# I added one because 0 is kept for unknown
targets_enc = np.array(targets_enc) + 1
print(targets_enc)
print(len(lbl_enc.classes_))
train_imgs, test_imgs, train_targets, test_targets, _, test_orig_targets = model_selection.train_test_split(
image_files, targets_enc, targets_orig, test_size=0.1, random_state=42)
train_dataset = dataset.ClassificationDataset(image_paths=train_imgs,
targets=train_targets,
resize=(config.IMAGE_HEIGHT,
config.IMAGE_WIDTH))
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=True)
test_dataset = dataset.ClassificationDataset(image_paths=test_imgs,
targets=test_targets,
resize=(config.IMAGE_HEIGHT,
config.IMAGE_WIDTH))
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=False)
model = CaptchaModel(num_chars=len(lbl_enc.classes_))
model.to(config.DEVICE)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
factor=0,
patience=5,
verbose=True)
for epoch in range(config.EPOCHS):
train_loss = engine.train_fn(model, train_loader, optimizer)
valid_preds, valid_loss = engine.eval_fn(model, test_loader)
valid_cap_preds = []
for vp in valid_preds:
current_preds = decode_predictions(vp, lbl_enc)
valid_cap_preds.extend(current_preds)
print(list(zip(test_orig_targets, valid_cap_preds))[6:11])
print(
f"Epoch: {epoch}, train_loss={train_loss}, valid_loss={valid_loss}"
)
# notice always_apply=True. we always want to apply
# normalization
aug = albumentations.Compose([
albumentations.Normalize(mean,
std,
max_pixel_value=255.0,
always_apply=True)
])
# instead of using k-fold, i am using train test split with a fixed random state
train_images, valid_images, train_targets, valid_targets = train_test_split(
images, targets, strafity=targets, random_state=42)
# fetch the ClassificationDataset class
train_dataset = dataset.ClassificationDataset(
image_paths=train_images,
targets=train_targets,
resize=(227, 227),
augmentations=aug,
)
# torch dataloader creates batches of data
# from classification dataset class
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=16,
shuffle=True,
num_workers=4)
# same for validation data
valid_dataset = dataset.ClassificationDataset(
image_paths=valid_images,
targets=valid_targets,
resize=(227, 227),
augmentations=aug,
)
def run_training():
# Create pathlib.Path for the data
data_path = Path(config.data_dir)
image_files = list(data_path.glob("*.png"))
targets = []
targets_orig = []
targets_unique = set()
# Loop through each file and create target list
for file in data_path.iterdir():
targets_orig.append(file.stem) # append the filename
targets.append(list(file.stem)) # append the list of chars
targets_unique.update(list(file.stem)) # keep track of unique chars
msg = "Number of target data-points: {}, \nUnique chars: {} \n"
print(msg.format(len(targets), sorted(targets_unique)))
# Label encode
le = preprocessing.LabelEncoder()
le.fit(sorted(targets_unique))
targets_encoded = [le.transform(x) for x in targets]
targets_encoded = np.array(targets_encoded) + 1 # adding 1 because 0 represents "unkwown"
msg = "Encoded targets: \n{}"
print(msg.format(targets_encoded))
# Split the dataset
train_images, test_images, train_targets, test_targets, train_orig_targets, test_orig_targets = \
model_selection.train_test_split(
image_files, targets_encoded, targets_orig, test_size=0.1, random_state=42
)
train_dataset = dataset.ClassificationDataset(image_paths=train_images,
targets=train_targets,
resize=(config.image_height, config.image_width))
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config.batch_size,
num_workers=config.num_workers,
shuffle=True
)
test_dataset = dataset.ClassificationDataset(image_paths=test_images,
targets=test_targets,
resize=(config.image_height, config.image_width))
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=config.batch_size,
num_workers=config.num_workers,
shuffle=False
)
# Create instance of the model and assign to gpu
model = CaptchaModel(num_chars=len(le.classes_))
# model.to(config.device)
model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
optimizer, factor=0.8, patience=5, verbose=True
)
prev_val_loss = sys.maxsize
for epoch in range(config.epochs):
# Train the model over all train batches
train_loss = train(model, train_loader, optimizer)
# Test the model over test batches
val_preds, val_loss = eval(model, test_loader)
# Print out the actual label and predicted labels
# Loop through and pass each batch to the decode function
val_preds_tmp = []
for vp in val_preds:
vp = decode_predictions(vp, le)
val_preds_tmp.extend(vp)
val_preds = val_preds_tmp
# Print out the first 5 predictions for the test set each epoch
print(f"Epoch: {epoch+1}, Train loss: {train_loss}, Val loss: {val_loss}")
pprint(list(zip(test_orig_targets, val_preds))[:5])
# Save the model if val_loss decreased
if val_loss <= prev_val_loss:
print(f"Val loss decreased from {prev_val_loss} to {val_loss}. Saving model.")
torch.save(model.state_dict(), Path(config.output_dir)/'captcha_model.pkl')
prev_val_loss = val_loss
print("\n\n")
test_Y = real_images[test_indices][:70000]
train_labels = labels[train_indices]
test_labels = labels[test_indices]
val_labels = labels[val_indices]
model = Deep_Res_Unet()
if is_model_trained:
model.load_state_dict(checkpoint["model"])
# move model to device
model.to(device)
train_dataset = dataset.ClassificationDataset(meas_images=train_X,
real_images=train_Y,
labels=train_labels)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=8,
shuffle=True,
num_workers=2)
valid_dataset = dataset.ClassificationDataset(meas_images=val_X,
real_images=val_Y,
labels=val_labels)
valid_loader = torch.utils.data.DataLoader(valid_dataset,
batch_size=8,
shuffle=False,
num_workers=2)
default=50000,
help='Number of algorithm iterations')
args = parser.parse_args()
comm = MPI.COMM_WORLD
node_id = comm.Get_rank()
nb_nodes = comm.size
log = get_logger(node_id)
# Initialize the graph (grid with nb_nodes nodes)
grid_graph = graph.Grid(nb_nodes, args.seed, tau=args.tau)
# Initialize the synthetic dataset
dataset = dataset.ClassificationDataset(seed=args.seed,
nb_points=args.nb_points_per_node *
nb_nodes,
d=args.d)
# Initialize the model
model = logistic_regression.LogisticRegression(dataset, nb_nodes * args.c)
# Initialize the algorithm
algo = adfs.ADFS(comm=comm,
seed=args.seed,
graph=grid_graph,
model=model,
log=log)
# Run the algorithm
algo.run(args.n_steps)
def run_training():
image_files = glob.glob(os.path.join(config.DATA_DIR, "*.png"))
# "/../../sdfrt.png" the next line only select the name of the file: sdfrt
targets_orig = [x.split("/")[-1][:-4] for x in image_files]
# sdfrt -> [s, d, f, r, t]
targets = [[c for c in x] for x in targets_orig]
targets_flat = [c for clist in targets for c in clist]
lbl_enc = preprocessing.LabelEncoder()
lbl_enc.fit(targets_flat)
# Encode the targets
targets_enc = [lbl_enc.transform(x) for x in targets]
# Transform targets_enc to np.array
# The labels are encoded from 0 to N-1 where N is the number of labels
# we want to keep 0 to unknown so add 1
targets_enc = np.array(targets_enc) + 1
print(targets)
print(np.unique(targets_flat))
print(targets_enc)
print(len(lbl_enc.classes_))
# split in train, test for: imgs, targets, orig_targets
train_imgs, test_imgs, train_targets, test_targets, _, test_orig_targets = \
model_selection.train_test_split(image_files,
targets_enc, targets_orig,
test_size=0.1, random_state=42)
train_dataset = dataset.ClassificationDataset(image_paths=train_imgs, targets=train_targets,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH))
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=True
)
test_dataset = dataset.ClassificationDataset(image_paths=test_imgs, targets=test_targets,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH))
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=False,
)
model = CaptchaModel(num_chars=len(lbl_enc.classes_))
model.to(config.DEVICE)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
optimizer, factor=0.8, patience=5, verbose=True
)
for epoch in range(config.EPOCHS):
train_loss = engine.train_fn(model, train_loader, optimizer)
valid_preds, valid_loss = engine.train_fn(model, test_loader)
valid_cap_preds = []
for valid_pred in valid_preds:
current_preds = decode_predictions(valid_pred, lbl_enc)
valid_cap_preds.extend(current_preds)
pprint(list(zip(test_orig_targets, valid_cap_preds))[6:10])
print(f"Epoch: {epoch}, train_loss={train_loss}, valid_loss={valid_loss}")
def run_training(plot_losses=False):
image_files = glob.glob(os.path.join(config.DATA_DIR, "*.jpg"))
targets_orig = [x.split("\\")[-1].split(".")[0] for x in image_files]
lbl_enc = preprocessing.LabelEncoder()
lbl_enc.fit(targets_orig)
targets_enc = lbl_enc.transform(targets_orig)
(
train_imgs,
test_imgs,
train_targets,
test_targets,
train_orig_targets,
test_orig_targets,
) = model_selection.train_test_split(image_files,
targets_enc,
targets_orig,
test_size=0.1,
random_state=42)
train_dataset = dataset.ClassificationDataset(
image_paths=train_imgs,
targets=train_targets,
resize=(config.IMG_HEIGHT, config.IMG_WIDTH),
)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=True,
)
test_dataset = dataset.ClassificationDataset(
image_paths=test_imgs,
targets=test_targets,
resize=(config.IMG_HEIGHT, config.IMG_WIDTH),
)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=False,
)
model = DogCatModel(len(lbl_enc.classes_))
model.to(config.DEVICE)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
factor=0.8,
patience=5,
verbose=True)
train_loss_hist = []
valid_loss_hist = []
for epoch in range(config.EPOCHS):
train_loss = engine.train_fn(model, train_loader, optimizer)
valid_preds, valid_loss = engine.eval_fn(model, test_loader)
#valid_cap_preds = []
#for vp in valid_preds:
#current_preds = decode_predictions(vp, lbl_enc)
#valid_cap_preds.extend(current_preds)
train_loss_hist.append(train_loss)
valid_loss_hist.append(valid_loss)
#pprint(list(zip(test_orig_targets, valid_cap_preds))[6:11])
print(
f"Epoch: {epoch}, train_loss={train_loss}, valid_loss={valid_loss}"
)
if plot_losses:
visuals.plot_loss(train_loss_hist,
loss2=valid_loss_hist,
loss1_label="Train Loss",
loss2_label="Val. Loss",
save_path="loss_plots.png")
torch.save(model.state_dict(), "trained_model.pckl")
def run_training():
image_files = glob.glob(os.path.join(config.DATA_DIR, "*.png"))
targets_orig = [x.split("/")[-1][:-4].split('_')[0] for x in image_files]
targets = [[c for c in x] for x in targets_orig]
targets_flat = [c for clist in targets for c in clist]
lbl_enc = preprocessing.LabelEncoder()
lbl_enc.fit(targets_flat)
np.save(config.LABEL_ENCODER_SAVE_PATH, lbl_enc.classes_)
targets_enc = [lbl_enc.transform(x) for x in targets]
# print(targets_enc)
# new_targets_enc= []
# for i,target in enumerate(targets_enc):
# tmp = np.array([-1,-1,-1,-1,-1])
# for idx, item in enumerate(target):
# # print(idx)
# # print('i',i)
# tmp[idx] = item
# # print(image_files[i])
# new_targets_enc.append(tmp)
# print(new_targets_enc)
targets_enc = np.array(targets_enc)
targets_enc = targets_enc + 1
(
train_imgs,
test_imgs,
train_targets,
test_targets,
_,
test_targets_orig,
) = model_selection.train_test_split(
image_files, targets_enc, targets_orig, test_size=0.1, random_state=42
)
train_dataset = dataset.ClassificationDataset(
image_paths=train_imgs,
targets=train_targets,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH),
)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=True,
)
test_dataset = dataset.ClassificationDataset(
image_paths=test_imgs,
targets=test_targets,
resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH),
)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=config.BATCH_SIZE,
num_workers=config.NUM_WORKERS,
shuffle=False,
)
model = CaptchaModel(num_chars=len(lbl_enc.classes_))
model.to(config.DEVICE)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
optimizer, factor=0.8, patience=5, verbose=True
)
for epoch in range(config.EPOCHS):
train_loss = engine.train_fn(model, train_loader, optimizer)
valid_preds, test_loss = engine.eval_fn(model, test_loader)
valid_captcha_preds = []
for vp in valid_preds:
current_preds = decode_predictions(vp, lbl_enc)
valid_captcha_preds.extend(current_preds)
combined = list(zip(test_targets_orig, valid_captcha_preds))
print(combined[:10])
test_dup_rem = test_targets_orig
accuracy = metrics.accuracy_score(test_dup_rem, valid_captcha_preds)
print(
f"Epoch={epoch}, Train Loss={train_loss}, Test Loss={test_loss} Accuracy={accuracy}"
)
scheduler.step(test_loss)
torch.save(model.state_dict(), config.MODEL_SAVE_PATH)
test_size=0.15)
# # binary targets numpy array
# targets = df.target.values
# # fetch out model, we will try both pretrained
# # and non-pretrained weights
model = Dense_Unet()
if is_model_trained:
model.load_state_dict(checkpoint["model"])
# move model to device
model.to(device)
train_dataset = dataset.ClassificationDataset(image_paths=train_X,
targets=train_Y,
resize=(256, 256))
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=8,
shuffle=True,
num_workers=2)
valid_dataset = dataset.ClassificationDataset(image_paths=val_X,
targets=val_Y,
resize=(256, 256))
valid_loader = torch.utils.data.DataLoader(valid_dataset,
batch_size=8,
shuffle=False,
num_workers=2)
