def bakeGenerator(annot):
lines = open(annot, 'r').read().strip().split('\n')
x_set = [line.split()[0] for line in lines]
y_set = [line.split()[1] for line in lines]
# x_set = glob.glob(os.path.join(root, 'raw', '*.jpg'))
# y_set = glob.glob(os.path.join(root, 'mask', '*.jpg'))
gen = DataGenerator(x_set, y_set, batch_size=batch_size, shuffle=True)
return gen
for item in data.dataset['train']:
f.write(f"TR_L {item}\n")
for item, noise in zip(data.dataset['valid'], valid_noised):
f.write(f"VA_L {item}\nVA_P {noise}\n")
for item, noise in zip(data.dataset['test'], test_noised):
f.write(f"TE_L {item}\nTE_P {noise}\n")
else:
assert os.path.isfile(source_path) or os.path.isfile(target_path)
os.makedirs(output_path, exist_ok=True)
dtgen = DataGenerator(source=source_path,
batch_size=args.batch_size,
charset=(charset_base + charset_special),
max_text_length=max_text_length,
predict=args.test)
if args.mode in ['similarity', 'norvig', 'symspell', 'kaldi']:
lm = LanguageModel(mode=args.mode, output=output_path, N=args.N)
if args.train:
if args.mode == "kaldi":
lm.autocorrect(sentences=None, predict=args.test)
else:
corpus = lm.create_corpus(dtgen.dataset['train']['gt'] +
dtgen.dataset['valid']['gt'] +
dtgen.dataset['test']['gt'])
with open(os.path.join(output_path, "corpus.txt"),
print("\nProb. - Predict")
for (pd, pb) in zip(pred, prob):
print(f"{pb:.4f} - {pd}")
cv2.imshow(f"Image {i + 1}", pp.adjust_to_see(img))
print("\n####################################")
cv2.waitKey(0)
else:
assert os.path.isfile(source_path) or os.path.isfile(target_path)
os.makedirs(output_path, exist_ok=True)
dtgen = DataGenerator(source=source_path,
batch_size=args.batch_size,
charset=charset_base,
max_text_length=max_text_length,
predict=args.test)
model = HTRModel(architecture=args.arch,
input_size=input_size,
vocab_size=dtgen.tokenizer.vocab_size)
model.compile(learning_rate=0.001)
model.load_checkpoint(target=target_path)
if args.train:
model.summary(output_path, "summary.txt")
callbacks = model.get_callbacks(logdir=output_path,
checkpoint=target_path,
verbose=1)
os.makedirs(output_path, exist_ok=True)
# define input size, number max of chars per line and list of valid chars
input_size = (1024, 128, 1)
max_text_length = 128
charset_base = string.printable[:95]
print("source:", source_path)
print("output", output_path)
print("target", target_path)
print("charset:", charset_base)
from data.generator import DataGenerator
dtgen = DataGenerator(source=source_path,
batch_size=batch_size,
charset=charset_base,
max_text_length=max_text_length)
print(f"Train images: {dtgen.size['train']}")
print(f"Validation images: {dtgen.size['valid']}")
print(f"Test images: {dtgen.size['test']}")
from network.model import HTRModel
# create and compile HTRModel
model = HTRModel(architecture=arch,
input_size=input_size,
vocab_size=dtgen.tokenizer.vocab_size,
beam_width=10,
stop_tolerance=20,
reduce_tolerance=15)
else:
assert os.path.isfile(source_path) or os.path.isfile(target_path)
os.makedirs(output_path, exist_ok=True)
if args.train:
device = torch.device(args.device)
model = make_model(tokenizer.vocab_size,
hidden_dim=256,
nheads=4,
num_encoder_layers=4,
num_decoder_layers=4)
model.to(device)
train_loader = torch.utils.data.DataLoader(
DataGenerator(source_path, charset_base, max_text_length,
'train', transform),
batch_size=args.batch_size,
shuffle=False,
num_workers=2)
val_loader = torch.utils.data.DataLoader(
DataGenerator(source_path, charset_base, max_text_length,
'valid', transform),
batch_size=args.batch_size,
shuffle=False,
num_workers=2)
criterion = LabelSmoothing(size=tokenizer.vocab_size,
padding_idx=0,
smoothing=0.1)
criterion.to(device)
lr = args.lr # learning rate
from data.generator import DataGenerator
datagen = DataGenerator()
def get_most_viewed_screens_by_all_time(sessions):
screens_time_map = {}
for session in sessions:
session_screens = session.get('screens', [])
for screen in session_screens:
screen_id = screen['id']
screen_time = screen['time']
total_screen_time = screens_time_map.get(screen['id'], 0)
screens_time_map[screen_id] = total_screen_time + screen_time
sorted_screen_ids = sorted(screens_time_map.keys(),
key=lambda key: screens_time_map[key],
reverse=True)
sorted_screens = [{
'screen': datagen.get_screen_by_id(screen_id),
'time': screens_time_map[screen_id]
} for screen_id in sorted_screen_ids]
return sorted_screens
def get_most_viewed_screens_by_count(sessions):
screens_time_map = {}
for session in sessions:
session_screens = session.get('screens', [])
with h5py.File(hdf5_src, "r") as hf:
dt = hf["test"]["dt"][:]
gt = hf["test"]["gt"][:]
for x in range(len(dt)):
print(f"Image shape: {dt[x].shape}")
print(f"Ground truth: {gt[x].decode()}\n")
cv2.imshow("img", pp.adjust_to_see(dt[x]))
cv2.waitKey(0)
elif args.train or args.test:
os.makedirs(output_path, exist_ok=True)
dtgen = DataGenerator(hdf5_src=hdf5_src,
batch_size=args.batch_size,
charset=charset_base,
max_text_length=max_text_length)
network_func = getattr(architecture, args.arch)
ioo = network_func(input_size=input_size,
output_size=(dtgen.tokenizer.vocab_size + 1),
learning_rate=0.001)
model = HTRModel(inputs=ioo[0], outputs=ioo[1])
model.compile(optimizer=ioo[2])
checkpoint = "checkpoint_weights.hdf5"
model.load_checkpoint(target=os.path.join(output_path, checkpoint))
if args.train:
lambda x: 1 if class_name in x else 0)
BATCH_SIZE = 32
train_imgs, val_imgs = train_test_split(train['Image'].values,
test_size=0.2,
stratify=train['Class'].map(lambda x: str(sorted(list(x)))),
random_state=2019)
img_2_ohe_vector = {img: vec for img, vec in zip(train['Image'], train.iloc[:, 2:].values)}
albumentations_train = Compose([
VerticalFlip(), HorizontalFlip(), Rotate(limit=20), GridDistortion()
], p=1)
data_generator_train = DataGenerator(train_imgs, augmentation=albumentations_train, img_2_ohe_vector=img_2_ohe_vector)
data_generator_train_eval = DataGenerator(train_imgs, shuffle=False, img_2_ohe_vector=img_2_ohe_vector)
data_generator_val = DataGenerator(val_imgs, shuffle=False, img_2_ohe_vector=img_2_ohe_vector)
train_metric_callback = PrAucCallback(data_generator_train_eval)
val_callback = PrAucCallback(data_generator_val, stage='val')
# Unet model
# preprocess = get_preprocessing('resnet34') # for resnet, img = (img-110.0)/1.0
# model = Unet('resnet34', input_shape=(256, 256, 3),
# classes=4, activation='sigmoid')
# EfficientNet model
def get_model():
K.clear_session()
base_model = efn.EfficientNetB2(weights='imagenet', include_top=False, pooling='avg', input_shape=(256, 256, 3))
# define input size, number max of chars per line and list of valid chars
input_size = (1024, 128, 1)
max_text_length = 128
charset_base = string.printable[:95]
print("source:", source_path)
print("output", output_path)
print("target", target_path)
print("charset:", charset_base)
#TODO DataGenerator Class
from data.generator import DataGenerator
dtgen = DataGenerator(source=source_path,
batch_size=batch_size,
charset=charset_base,
max_text_length=max_text_length)
print(f"Train images: {dtgen.size['train']}")
print(f"Validation images: {dtgen.size['valid']}")
print(f"Test images: {dtgen.size['test']}")
#TODO HTRModel Class
from network.model import HTRModel
# create and compile HTRModel
model = HTRModel(architecture=arch,
input_size=input_size,
vocab_size=dtgen.tokenizer.vocab_size,
beam_width=10,
stop_tolerance=20,
force_images=False,
scale_around_zero=True,
size_cropped=(256, 256),
size_output=(64, 64),
suffixes=[
['ed-after', 'ed-v'],
],
)
#%%
image_generator_type = 'Bicycle'
if image_generator_type == 'Pix2Pix':
image_generator = Pix2Pix(
training_generator=DataGenerator(train_set, shuffle=True),
validation_generator=DataGenerator(validation_set, shuffle=True),
result_path=data.result_path,
generator_path=data.model_path / 'predict-gen-6.h5',
discriminator_path=data.model_path / 'predict-dis-6.h5',
)
elif image_generator_type == 'VAE':
image_generator = VAE(
training_generator=DataGenerator(train_set, shuffle=True),
validation_generator=DataGenerator(validation_set, shuffle=True),
result_path=data.result_path,
model_path=data.model_path / 'predict-vae-2.h5',
)
elif image_generator_type == 'Bicycle':
