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)