def exp_draw():
config = Config()
dataloader = DataLoader()
#read a
with open(sys.path[0] + "/../a") as a_in:
aid = a_in.read().split('\n')[0]
#read
with open(sys.path[0] + "/../n") as n_in:
nids = n_in.read().split('\n')
#nids.remove('None')
if '' in nids:
nids.remove('')
cate_trees = generate_category_tree(dataloader)
rlt_dist = {1.:[], 0.1:[], 0.01:[], 0.001:[], 0.0001:[]}
x_axis = ['0%', '20%', '40%', '60%', '80%', '100%']
fig, axs = plt.subplots(ncols=5)
sigmas = [1., 0.1, 0.01, 0.001, 0.0001]
for row, sigma in enumerate(sigmas):
ax = axs[row]
data = dataloader.load(vectorized_convertor, pivots = cate_trees, sigma=sigma, valid_uid=[aid] + nids)
avec = data[0]
nvecs = data[1:]
for nv in nvecs:
rlt_dist[sigma].append(vectorized_dist_calculator(np.array(avec), np.array(nv)))
print rlt_dist[sigma]
ax.bar(x_axis, rlt_dist[sigma] + [0.0], width = 0.4)
for a, b in zip(x_axis, rlt_dist[sigma] + [0.0]):
ax.text(a, b+0.000000001, '%f'%b, ha='center', va= 'bottom',fontsize=7)
ax.set_title(str(sigma))
plt.show()
def generate_eighty_percent():
dataloader = DataLoader()
#read a
with open(sys.path[0] + "/../a") as a_in:
aid = a_in.read().split('\n')[0]
#read
with open(sys.path[0] + "/../n") as n_in:
nids = n_in.read().split('\n')
#nids.remove('None')
if '' in nids:
nids.remove('')
cate_trees = generate_category_tree(dataloader)
def cluster_convertor(uid, bus_cate_dict, kwargs):
return [uid, bus_cate_dict.keys()]
data = dataloader.load(cluster_convertor, valid_uid=[aid] + nids)
a_data = data[0]
u_data = data[-1]
print '==============='
print a_data
for u_data in data[1:]:
print '=================='
print u_data
a_set = set(a_data[1])
u_set = set(u_data[1])
print float(len(a_set.intersection(u_set)))/float(len(a_set.union(u_set)))
def main():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args.config)
except:
print("missing or invalid arguments")
exit(0)
# create the experiments dirs
# create_dirs([config.summary_dir, config.checkpoint_dir, config.visual_dir])
print('Create the data generator.')
data_generator = DataLoader(config)
print('Create the model.')
models = BlurEnsemble(config)
print('Create the trainer')
trainer = BlurEnsembleTrainer(models.models,
data_generator.get_train_data(),
data_generator.get_test_data(), config)
print('Start training the model.')
trainer.train_gen()
print('Visualize the losses')
def main():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args.config)
except:
print("missing or invalid arguments")
exit(0)
# create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir, config.visual_dir])
models = {
'noise_model1': NoiseModel.build_model1(config),
'noise_model2': NoiseModel.build_model2(config),
'noise_model3': NoiseModel.build_model3(config)
}
print('Create the data generator.')
data_generator = DataLoader(config)
print('Create the model.')
model = models[config.exp_name]
print('Create the trainer')
trainer = NoiseModelTrainer(model, data_generator.get_train_data(), config)
print('Start training the model.')
trainer.train()
print('Visualize the losses')
trainer.visualize()
def main():
ctpn = CTPN(cfg)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
ctpn.load_ckpt(sess) # ctpn load
if cfg.ADJUST_ANGLE:
angle_detector = VGG(cfg) # vgg load
angle_detector.load_weights()
data = DataLoader(cfg)
text = TextGenerator(cfg)
densenet = DenseNet(cfg,text.nrof_classes)
densenet.load()
# image_path = raw_input("please input your image path and name:") # get image path
image_path = str('/home/jwm/Desktop/OCR-standard/images/xuanye.jpg')
img = data.load_data(image_path)
t = time.time()
if cfg.ADJUST_ANGLE:
img = rotate(img, angle_detector) # rotate image if necessary
# img = cv2.resize(img, (2000,3000),interpolation=cv2.INTER_CUBIC)
text_recs, detected_img, img = detect(img, data, ctpn, sess) # detect text
results = recognize(img, text_recs, densenet, text, adjust=False) # recognize text
print("It takes time:{}s".format(time.time() - t))
for key in results:
print(results[key][1])
def test_load(self):
loader = DataLoader()
def convert_func(uid, business_dict, arg_dict):
return {uid: business_dict.values()}
data = loader.load(convert_func, arg1=1)
print 'load done'
def train():
data_loader = DataLoader(data_dir='datasets/hymenoptera_data',
image_size=IMAGE_SIZE,
batch_size=4)
inputs, classes = next(iter(data_loader.load_data()))
out = torchvision.utils.make_grid(inputs)
data_loader.show_image(
out, title=[data_loader.data_classes[c] for c in classes])
def predict():
if len(sys.argv) > 1:
print('predict image from : {}'.format(sys.argv[1]))
data_loader = DataLoader(data_dir='datasets/hymenoptera_data', image_size=IMAGE_SIZE)
if os.path.exists(sys.argv[1]):
inputs = data_loader.make_predict_inputs(sys.argv[1])
predict_single_image(inputs, data_loader.data_classes)
else:
print('must specific image file path.')
def predict():
if len(sys.argv) > 1:
print('predict image from : {}'.format(sys.argv[1]))
data_loader = DataLoader(data_dir='datasets/hymenoptera_data',
image_size=IMAGE_SIZE)
if os.path.exists(sys.argv[1]):
inputs = data_loader.make_predict_inputs(sys.argv[1])
predict_single_image(inputs, data_loader.data_classes)
else:
print('must specific image file path.')
def reset_session(save_path, model, vggface, train_batchA, train_batchB):
model.save_weights(path=save_path)
K.clear_session()
model = FaceswapGANModel(**arch_config)
model.load_weights(path=save_path)
#vggface = VGGFace(include_top=False, model='resnet50', input_shape=(224, 224, 3))
vggface = RESNET50(include_top=False, weights=None, input_shape=(224, 224, 3))
vggface.load_weights("rcmalli_vggface_tf_notop_resnet50.h5")
model.build_pl_model(vggface_model=vggface, before_activ=loss_config["PL_before_activ"])
train_batchA = DataLoader(train_A, train_AnB, batchSize, img_dirA_bm_eyes,
RESOLUTION, num_cpus, K.get_session(), **da_config)
train_batchB = DataLoader(train_B, train_AnB, batchSize, img_dirB_bm_eyes,
RESOLUTION, num_cpus, K.get_session(), **da_config)
def main():
# get json configuration filepath from the run argument
# process the json configuration file
args = get_args()
config = process_config(args.config)
print('Create the data generator')
data_loader = DataLoader(config)
if config['all_weights_in_folder']:
weights = np.array(glob(os.path.dirname(os.path.abspath(config['weights_path'])) + '/*.hdf5'))
else:
weights = np.array([config['weights_path']])
for weight in weights:
weightnum = int(os.path.basename(weight).split('-')[-1:][0][:-5])
print('Create the model for weight #%s' % (weightnum))
model = CycleGANAttrModel(config, weight, is_train=False)
predict_set = config['predict_set'] # either a, b, both
model.build_predict_model(predict_set)
print('model ready loading data now')
os.makedirs('images/%s' % config['dataset_name'], exist_ok=True)
if predict_set=='both' or predict_set=='a':
testA_datagen = DataGenerator(img_filenames=data_loader.get_testA_data(), batch_size=1, target_size=(config['predict_img_height'], config['predict_img_width']))
testA_generator = iter(testA_datagen)
num_images = len(testA_datagen)
for i in range(num_images):
imgs_A = next(testA_generator)
fake_B = model.predict_g_AB.predict(imgs_A)
imageio.imwrite("images/%s/%i_a_transl_%i.png" % (config['dataset_name'], weightnum, i), ((fake_B[0]+1)*127.5).astype(np.uint8))
if predict_set=='both':
reconstr_A = model.predict_g_BA.predict(fake_B)
imageio.imwrite("images/%s/%i_a_recon_%i.png" % (config['dataset_name'], weightnum, i), ((reconstr_A[0]+1)*127.5).astype(np.uint8))
if predict_set=='both' or predict_set=='b':
testB_datagen = DataGenerator(img_filenames=data_loader.get_testB_data(), batch_size=1, target_size=(config['predict_img_height'], config['predict_img_width']))
testB_generator = iter(testB_datagen)
num_images = len(testB_datagen)
for i in range(num_images):
imgs_B = next(testB_generator)
fake_A = model.predict_g_BA.predict(imgs_B)
imageio.imwrite("images/%s/%i_b_transl_%i.png" % (config['dataset_name'], weightnum, i), ((fake_A[0]+1)*127.5).astype(np.uint8))
if predict_set=='both':
reconstr_B = model.predict_g_AB.predict(fake_A)
imageio.imwrite("images/%s/%i_b_recon_%i.png" % (config['dataset_name'], weightnum, i), ((reconstr_B[0]+1)*127.5).astype(np.uint8))
def reset_session(save_path, model, person='A'):
model.save_weights(path=save_path)
K.clear_session()
model = FaceswapGANModel(**arch_config)
model.load_weights(path=save_path)
vggface = VGGFace(include_top=False, model='resnet50', input_shape=(224, 224, 3))
model.build_pl_model(vggface_model=vggface, before_activ=loss_config["PL_before_activ"])
if person == 'A':
train_batch = DataLoader(gen_person_img, all_img, batchSize, gen_img_dir_bm_eyes,
RESOLUTION, num_cpus, K.get_session(), **da_config)
else:
train_batch = DataLoader(person_img, all_img, batchSize, img_dir_bm_eyes,
RESOLUTION, num_cpus, K.get_session(), **da_config)
return model, vggface, train_batch
class Generator:
def __init__(self, config):
self.config = config
self.reviews_data_loader = DataLoader(config.reviews.raw_data_path)
self.profiles_data_loader = DataLoader(config.profiles.raw_data_path)
self.products_data_loader = DataLoader(config.products.raw_data_path)
self.reviews_data = None
self.profiles_data = None
self.products_data = None
self.preprocessor = None
def load_data(self):
self.reviews_data = self.get_reviews_data()
self.profiles_data = self.get_profiles_data()
self.products_data = self.get_products_data()
def load_preprocessor(self):
self.preprocessor = Preprocessor(self.config, self.reviews_data,
self.profiles_data,
self.products_data)
def preprocess_reviews(self):
self.reviews_data = self.preprocessor.preprocess_reviews()
def preprocess_profiles(self):
self.profiles_data = self.preprocessor.preprocess_profiles()
def preprocess_products(self):
self.products_data = self.preprocessor.preprocess_products()
def get_reviews_data(self):
self.reviews_data_loader.load_data()
return self.reviews_data_loader.get_data()
def get_profiles_data(self):
self.profiles_data_loader.load_data()
return self.profiles_data_loader.get_data()
def get_products_data(self):
self.products_data_loader.load_data()
return self.products_data_loader.get_data()
def save_reviews_data(self):
self.reviews_data.to_csv(self.config.reviews.save_data_path,
index=False)
def save_profiles_data(self):
self.profiles_data.to_csv(self.config.profiles.save_data_path,
index=False)
def save_products_data(self):
self.products_data.to_csv(self.config.products.save_data_path,
index=False)
def train():
data_loader = DataLoader(data_dir='datasets/hymenoptera_data', image_size=IMG_SIZE, batch_size=4)
inputs, classes = next(iter(data_loader.load_data()))
out = torchvision.utils.make_grid(inputs)
data_loader.show_image(out, title=[data_loader.data_classes[c] for c in classes])
model = fine_tune_model()
criterion = nn.CrossEntropyLoss()
optimizer_ft = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
try:
model = train_model(data_loader, model, criterion, optimizer_ft, exp_lr_scheduler, num_epochs=25)
save_torch_model(model, MODEL_SAVE_FILE)
except KeyboardInterrupt:
print('manually interrupt, try saving model for now...')
save_torch_model(model, MODEL_SAVE_FILE)
print('model saved.')
def reset_session(save_path):
global model, vggface
global train_batchA, train_batchB
model.save_weights(path=save_path)
del model
del vggface
del train_batchA
del train_batchB
K.clear_session()
model = FaceswapGANModel(**arch_config)
model.load_weights(path=save_path)
vggface = VGGFace(include_top=False, model='resnet50', input_shape=(224, 224, 3))
model.build_pl_model(vggface_model=vggface, before_activ=loss_config["PL_before_activ"])
train_batchA = DataLoader(train_A, train_AnB, batchSize, img_dirA_bm_eyes,
RESOLUTION, num_cpus, K.get_session(), **da_config)
train_batchB = DataLoader(train_B, train_AnB, batchSize, img_dirB_bm_eyes,
RESOLUTION, num_cpus, K.get_session(), **da_config)
def main():
ctpn = CTPN(cfg)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
ctpn.load_ckpt(sess)
if cfg.ADJUST_ANGLE:
angle_detector = VGG(cfg)
angle_detector.load_weights()
data = DataLoader(cfg)
img = data.load_data('images/xuanye.jpg')
t = time.time()
if cfg.ADJUST_ANGLE:
angle = angle_detector.predict(img=np.copy(img))
print('The angel of this character is:', angle)
im = Image.fromarray(img)
print('Rotate the array of this img!')
if angle == 90:
im = im.transpose(Image.ROTATE_270)
elif angle == 180:
im = im.transpose(Image.ROTATE_180)
elif angle == 270:
im = im.transpose(Image.ROTATE_90)
img = np.array(im)
# img = cv2.resize(img, (2000,3000),interpolation=cv2.INTER_CUBIC)
blobs, im_scales, resized_img, scale = data.get_blobs(img, None)
boxes, scores = ctpn.predict(blobs, im_scales, resized_img, sess)
boxes = ctpn.detect(boxes, scores[:, np.newaxis], resized_img.shape[:2])
text_recs, im = draw_boxes(resized_img,
boxes,
caption='im_name',
wait=True,
is_display=True)
# text_recs = sort_box(text_recs)
print("It takes time:{}s".format(time.time() - t))
# cv2.imshow('img',im)
# cv2.waitKey(0)
cv2.imwrite('images/result.jpg', im)
class EditDistTest(unittest.TestCase):
def setUp(self):
self.data_loader = DataLoader()
self.data = self.data_loader.load(bottomup_edit_dist_converter)
config = Config().config
self.data_file_name = config['data_file_name']
self.cate_file_name = config['cate_file_name']
def deep_copy_tree(self, t):
uid = t.root.label
with open(self.data_file_name) as user_data_f:
user_data = json.load(user_data_f)[uid]
bus_dict = {}
for bid in user_data:
bus_dict[bid] = self.data_loader.get_business_cate_path(bid)
return bottomup_edit_dist_converter(uid, bus_dict, {})
def test_edit_dist(self):
random_index = int(random.random() * len(self.data))
base_tree = self.data[random_index]
# 1.dist(t1,t2) == dist(t2,t1)
random_index_2 = int(random.random() * len(self.data))
sec_tree = self.data[random_index_2]
assert bottomup_edit_dist_calculator(
sec_tree,
base_tree) == bottomup_edit_dist_calculator(base_tree, sec_tree)
# 2.same tree => dist==0
mirror_tree = self.deep_copy_tree(base_tree)
assert bottomup_edit_dist_calculator(mirror_tree, base_tree) == 0.0
# 3.dist(t1,t2) + dist(t2,t3) >= dist(t1,t3)
random_index_3 = int(random.random() * len(self.data))
thd_tree = self.data[random_index_3]
assert bottomup_edit_dist_calculator(
base_tree, sec_tree) + bottomup_edit_dist_calculator(
sec_tree, thd_tree) >= bottomup_edit_dist_calculator(
base_tree, thd_tree)
# 4.one empty and another not empty => dist == size(not empty tree)-1
empty_tree = BUEditTree('empty')
d = bottomup_edit_dist_calculator(empty_tree, base_tree)
assert base_tree.size - 1 == d
def main():
config = process_config(CONFIG_FILE)
# create the experiments dirs
create_dirs([config.tensorboard_log_dir, config.checkpoint_dir])
print('Create the data generator.')
data_loader = DataLoader(config)
print('Create the model.')
model = LSTMChem(config)
print('Create the trainer')
trainer = LSTMChemTrainer(model.model, data_loader.get_train_data(),
config)
print('Start training the model.')
trainer.train()
def getData(mypath, config):
# get list of filepaths
onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
data_dict = [mypath + "\\" + s for s in onlyfiles]
# create numpy datasets for each stock
data = []
for fname in data_dict:
data.append(
DataLoader(fname,
window=config.experiment.window,
threshold=config.experiment.threshold))
# initialize numpy arrays for training and test data
X_train = data[0].X_train_std
Y_train = data[0].Y_train
X_val = data[0].X_val_std
Y_val = data[0].Y_val
X_test = data[0].X_test_std
Y_test = data[0].Y_test
# add other stocks to previously initialized numpy arrays
for i in range(1, len(data)):
X_train = np.concatenate((X_train, data[i].X_train_std), axis=0)
Y_train = np.concatenate((Y_train, data[i].Y_train), axis=0)
X_val = np.concatenate((X_val, data[i].X_val_std), axis=0)
Y_val = np.concatenate((Y_val, data[i].Y_val), axis=0)
X_test = np.concatenate((X_test, data[i].X_test_std), axis=0)
Y_test = np.concatenate((Y_test, data[i].Y_test), axis=0)
# Save number of features and samples
num_train_samples = X_train.shape[0]
num_val_samples = X_val.shape[0]
num_test_samples = X_test.shape[0]
num_train_features = X_train.shape[1]
# Generate TF dataset for Keras model
logging.info('------Final Training and Test Datasets------')
logging.info('Size of X_Train: %s', X_train.shape)
logging.info('Size of Y_Train: %s', Y_train.shape)
logging.info('Size of X_val: %s', X_val.shape)
logging.info('Size of Y_val: %s', Y_val.shape)
logging.info('Size of X_Test: %s', X_test.shape)
logging.info('Size of Y_Test: %s', Y_test.shape)
train_dataset = Dataset.from_tensor_slices((X_train, Y_train))
train_dataset = train_dataset.shuffle(config.model.shuffle).batch(
config.model.batch_size).repeat()
val_dataset = Dataset.from_tensor_slices((X_val, Y_val))
val_dataset = val_dataset.shuffle(config.model.shuffle).batch(
config.model.batch_size).repeat()
test_dataset = Dataset.from_tensor_slices((X_test, Y_test))
test_dataset = test_dataset.shuffle(config.model.shuffle).batch(
config.model.batch_size).repeat()
return train_dataset, val_dataset, test_dataset, num_train_features, num_train_samples, num_val_samples, num_test_samples
def main():
try:
args = get_args()
config = process_config(args.config)
except:
print("Missing or invalid arguments")
exit(0)
create_dirs([config.summary_dir, config.checkpoint_dir])
#sess = tf.Session()
print("Loading dataset")
data = DataLoader(config, args.preprocess)
print("Finished loading dataset")
data.next_batch()
model = Biaxial(config)
logger = Logger(sess, config)
trainer = Trainer(sess, model, data, config, logger)
model.load(sess)
trainer.train()
def train():
model = CTPN(cfg)
data = DataLoader(cfg)
# imdb = data.load_imdb('voc_2007_trainval')
# roidb = data.get_training_roidb(imdb)
sess = get_sess()
logger = Logger(sess, cfg)
trainer = CTPNTrainer(sess, model, data, logger)
print('Solving...')
trainer.train(cfg.TRAIN.MAX_ITERS, restore=False)
print('done solving')
def main():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args.config)
except:
print("missing or invalid arguments")
exit(0)
# create the experiments dirs
create_dirs([
config.callbacks.tensorboard_log_dir, config.callbacks.checkpoint_dir
])
print('Create the data generator.')
data_loader = DataLoader(config)
while True:
images = next(data_loader.get_train_generator())
print(images)
def main():
# get json configuration filepath from the run argument
# process the json configuration file
args = get_args()
config = process_config(args.config)
# create the experiment directories
log_dir, checkpoint_dir = create_dirs(config)
print('Create the data generator')
data_loader = DataLoader(config)
print('Create the model')
model = CycleGANAttrModel(config, config['weights_path'])
model.build_model()
print('model ready loading data now')
print('Create the trainer')
trainer = CycleGANModelTrainer(model, data_loader.get_trainA_data(),
data_loader.get_trainB_data(),
data_loader.get_testA_data(),
data_loader.get_testB_data(), config,
log_dir, checkpoint_dir)
# print('Start training the model.')
trainer.train()
def main():
try:
args = get_args()
config = process_config(args.config)
except:
print("Missing Arguments")
exit(0)
sess = tf.Session()
data = DataLoader("./data/celebA/images/", "./data/celebA/list_attr_celeba.txt", 178, 128, 16, "train")
model = StarGAN(config, data)
logger = Logger(sess, config)
trainer = StarGANTrainer(sess, model, data, config, logger)
trainer.train()
def __init__(self, config):
self.config = config
self.reviews_data_loader = DataLoader(config.reviews.raw_data_path)
self.profiles_data_loader = DataLoader(config.profiles.raw_data_path)
self.products_data_loader = DataLoader(config.products.raw_data_path)
self.reviews_data = None
self.profiles_data = None
self.products_data = None
self.preprocessor = None
def main():
ctpn = CTPN(cfg)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
ctpn.load_ckpt(sess) # ctpn load
if torch.cuda.is_available() and cfg.ALL_GPU:
crnn = CRNN(cfg, 32, 1, len(cfg.KEYS) + 1, 256, 1).cuda()
else:
crnn = CRNN(cfg, 32, 1, len(cfg.KEYS) + 1, 256, 1).cpu()
crnn.eval()
crnn.load_state_dict(torch.load(cfg.CRNN_MODEL)) # crnn load
if cfg.ADJUST_ANGLE:
angle_detector = VGG(cfg) # vgg load
angle_detector.load_weights()
data = DataLoader(cfg)
text = TextGenerator(cfg)
# image_path = raw_input("please input your image path and name:") # get image path
image_path = str('/home/jwm/Desktop/OCR-standard/images/xuanye.jpg')
img = data.load_data(image_path)
t = time.time()
if cfg.ADJUST_ANGLE:
img = rotate(img, angle_detector) # rotate image if necessary
# img = cv2.resize(img, (2000,3000),interpolation=cv2.INTER_CUBIC)
text_recs, detected_img, img = detect(img, data, ctpn, sess) # detect text
results = recognize(img, text_recs, crnn, text,
adjust=True) # recognize text
print("It takes time:{}s".format(time.time() - t))
for key in results:
print(results[key][1])
class ClusteringTest(unittest.TestCase):
def setUp(self):
self.data_loader = DataLoader()
with open('testData1000','r') as valid_uid_f:
self.valid_uid = valid_uid_f.read().split('\n')
def test_vec_ctc(self):
pivots = generate_category_tree(self.data_loader)
data = self.data_loader.load(vectorized_convertor, pivots=pivots, sigma=0.0001, valid_uid=self.valid_uid)
dct = DensityCoverTree(vectorized_dist_calculator, 3)
for i, d in enumerate(data):
dct.insert(Node(val=d, index=i))
for cls in covertree_clustering(dct, 4):
print 'stub'
class VectorizedUserDistTester(unittest.TestCase):
def setUp(self):
self.data_loader = DataLoader()
self.pivots = generate_category_tree(self.data_loader)
self.data = self.data_loader.load(vectorized_convertor,
pivots=self.pivots,
sigma=0.0001)
def test_dist(self):
random_index = int(len(self.data) * random.random())
for d_1 in self.data:
d_2 = self.data[random_index]
assert vectorized_dist_calculator(
d_1, d_2) >= 0 and vectorized_dist_calculator(
d_1, d_2) <= np.sqrt(len(d_1))
def main():
# capture the config path from the run arguments
args = get_args()
# process the json configuration file
config = process_config(args.config)
# configure devices
os.environ["CUDA_VISIBLE_DEVICES"] = config.gpus
import tensorflow as tf
from data_loader.data_loader import DataLoader
from models.gan_model import GANModel
# set GPUS configuration
gpuconfig = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
gpuconfig.gpu_options.visible_device_list = config.gpus
gpuconfig.gpu_options.allow_growth = True
# create tensorflow session
sess = tf.Session(config=gpuconfig)
# create your data generator
data = DataLoader(config)
# create an instance of the model
model = GANModel(data, config)
# load model
model.load(sess)
# generate random noise vector (could replace by a specified noise)
noise = tf.random_normal([1, config.latent_vec_dim])
noise = tf.tile(noise, [config.batch_size, 1])
label = np.zeros((config.batch_size, 1))
for i in range(config.batch_size):
label[i] = -1 + 2 * i / config.batch_size
noise = sess.run(noise)
generated_charts = sess.run(
model.generator(tf.convert_to_tensor(noise),
tf.cast(tf.convert_to_tensor(label), tf.float32)))
# create generations folder
generations_path = os.path.join('experiments', config.exp_name,
'generations')
if not os.path.isdir(generations_path):
os.mkdir(generations_path)
sio.savemat(os.path.join(generations_path, 'generated_charts'),
{'generated_charts': generated_charts})
print('done')
def main():
# capture the config path from the run arguments
# then process the json configration file
# try:
data_loader = DataLoader(data_dir, config)
data_loader.load_directory('.tif')
data_loader.create_np_arrays()
data_loader.create_data_label_pairs()
preptt = PrepTrainTest(config, data_loader)
for data_label_pair in data_loader.data_label_pairs:
x_data = data_label_pair[0][data_loader]
y_true = data_label_pair[1][data_loader.data_label_pairs[i][1][:, :, 0]]
preptt.add_data(x_data, y_true)
# Create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir, config.input_dir])
# Create tensorflow session
sess = tf.Session()
# Create instance of the model you want
model = PopModel(config)
# Load model if exist
model.load(sess)
# Create Tensorboard logger
logger = Logger(sess, config)
logger.log_config()
# Create your data generator
data = DataGenerator(config, preptraintest = preptt)
data.create_traintest_data()
# Create trainer and path all previous components to it
trainer = PopTrainer(sess, model, data, config, logger)
# Train model
trainer.train()
def train():
data_loader = DataLoader(data_dir='datasets/hymenoptera_data', image_size=IMAGE_SIZE, batch_size=4)
inputs, classes = next(iter(data_loader.load_data()))
out = torchvision.utils.make_grid(inputs)
data_loader.show_image(out, title=[data_loader.data_classes[c] for c in classes])
