def _download_module(self, module_url):
request = self.request
session = request.session
conn = sword2cnx.Connection(session['login'].service_document_url,
user_name=session['login'].username,
user_pass=session['login'].password,
always_authenticate=True,
download_service_document=False)
parts = urlparse.urlsplit(module_url)
path = parts.path.split('/')
path = path[:path.index('sword')]
module_url = '%s://%s%s' % (parts.scheme, parts.netloc, '/'.join(path))
# example: http://cnx.org/Members/user001/m17222/sword/editmedia
zip_file = conn.get_cnx_module(module_url = module_url,
packaging = 'zip')
save_dir = get_save_dir(request)
if save_dir is None:
request.session['upload_dir'], save_dir = create_save_dir(request)
extract_to_save_dir(zip_file, save_dir)
cnxml_file = open(os.path.join(save_dir, 'index.cnxml'), 'rb')
cnxml = cnxml_file.read()
cnxml_file.close()
conversionerror = None
try:
htmlpreview = cnxml_to_htmlpreview(cnxml)
save_and_backup_file(save_dir, 'index.html', htmlpreview)
files = get_files(save_dir)
save_zip(save_dir, cnxml, htmlpreview, files)
except libxml2.parserError:
conversionerror = traceback.format_exc()
raise ConversionError(conversionerror)
def _download_module(self, module_url):
request = self.request
session = request.session
conn = sword2cnx.Connection(session['login'].service_document_url,
user_name=session['login'].username,
user_pass=session['login'].password,
always_authenticate=True,
download_service_document=False)
parts = urlparse.urlsplit(module_url)
path = parts.path.split('/')
path = path[:path.index('sword')]
module_url = '%s://%s%s' % (parts.scheme, parts.netloc, '/'.join(path))
# example: http://cnx.org/Members/user001/m17222/sword/editmedia
zip_file = conn.get_cnx_module(module_url=module_url, packaging='zip')
save_dir = get_save_dir(request)
if save_dir is None:
request.session['upload_dir'], save_dir = create_save_dir(request)
extract_to_save_dir(zip_file, save_dir)
cnxml_file = open(os.path.join(save_dir, 'index.cnxml'), 'rb')
cnxml = cnxml_file.read()
cnxml_file.close()
conversionerror = None
try:
structuredhtml = cnxml_to_structuredhtml(cnxml)
save_and_backup_file(save_dir, 'index.structured.html',
structuredhtml)
htmlpreview = structuredhtml_to_htmlpreview(structuredhtml)
save_and_backup_file(save_dir, 'index.html', htmlpreview)
files = get_files(save_dir)
save_zip(save_dir, cnxml, structuredhtml, files)
except libxml2.parserError:
conversionerror = traceback.format_exc()
raise ConversionError(conversionerror)
parser.add_argument('--loss', type=str, default='masked_bin_loss', help='loss to be used for training')
parser.add_argument('--export', action='store_true', help='Save model checkpoint or not?')
ARGS = parser.parse_args()
EXPERIMENT_TIMESTAMP = str(int(time.time()))
EPOCHS = ARGS.num_epochs
BATCHSIZE = ARGS.batch_size
NUM_LAYERS = ARGS.num_layers
CELL_SIZE = ARGS.cell_size
VAL_RATIO = ARGS.val_ratio
DROP_RATE = ARGS.dropout_rate
# Creating folder where model checkpoints will be saved
save_dir = utils.create_save_dir(ARGS, EXPERIMENT_TIMESTAMP, 'lstm')
# loading training data
data_path = ARGS.data_dir
data_embeddings = np.load(os.path.join(data_path, 'train_embeddings.npy'))
data_labels = np.load(os.path.join(data_path, 'train_labels.npy'))
data_mask = np.load(os.path.join(data_path, 'train_mask.npy'))
data_mask = data_mask.astype(np.float32)
# Checking if data shape is consistent or not
assert data_embeddings.shape[0] == data_labels.shape[0] == data_mask.shape[0]
print(data_embeddings.dtype)
print(data_labels.dtype)
print(data_mask.dtype)
num_time = data_labels.shape[1]
ARGS = parser.parse_args()
EXPERIMENT_TIMESTAMP = str(int(time.time()))
EPOCHS = ARGS.num_epochs
BATCHSIZE = ARGS.batch_size
train_input_path = os.path.join(ARGS.data_dir, 'train', 'train-*.tfrecord')
val_input_path = os.path.join(ARGS.data_dir, 'validation', 'train-*.tfrecord')
SEED = 88
input_shape = (None, 224, 224, 3)
label_shape = (None, 6)
# Creating save directory where model checkpoints and
# tensorboard files will be stored
save_dir = utils.create_save_dir(ARGS, EXPERIMENT_TIMESTAMP, 'base_model')
# loading resnet-50 or inception resnet computation
# graph and adding loss and optimizer to the graph
if ARGS.pretrained_model == 'resnet_50':
outputs, inputs, labels, is_train, _ = model.resnet_model(
input_shape, label_shape)
if ARGS.pretrained_model == 'inception_resnet':
outputs, inputs, labels, is_train, _ = model.inception_resnet_model(
input_shape, label_shape)
loss = model.build_loss(labels, outputs, loss_name=ARGS.loss)
prediction = tf.cast(tf.greater(tf.sigmoid(outputs), 0.5), tf.float32)
correct_prediction = tf.equal(labels[:, -1], prediction[:, -1])
correct_images = tf.boolean_mask(inputs, correct_prediction)
def train(config_filepath, save_dir, device, visualize_interval):
conf = load_toml_config(config_filepath)
data_dir, log_dir = create_save_dir(save_dir)
# Save config file
shutil.copyfile(config_filepath,
os.path.join(save_dir, os.path.basename(config_filepath)))
device = torch.device(device)
# Set up log metrics
metrics = {
'episode': [],
'episodic_step': [],
'collected_total_samples': [],
'reward': [],
'q_loss': [],
'policy_loss': [],
'alpha_loss': [],
'alpha': [],
'policy_switch_epoch': [],
'policy_switch_sample': [],
'test_episode': [],
'test_reward': [],
}
policy_switch_samples = conf.policy_switch_samples if hasattr(
conf, "policy_switch_samples") else None
total_collected_samples = 0
# Create environment
env = make_env(conf.environment, render=False)
# Instantiate modules
# memory = ReplayBuffer(int(conf.replay_buffer_capacity), env.observation_space.shape, env.action_space.shape)
memory = ReplayMemory(conf.replay_buffer_capacity)
agent = getattr(agents, conf.agent_type)(env.observation_space,
env.action_space,
device=device,
**conf.agent)
# Load checkpoint if specified in config
if conf.checkpoint != '':
ckpt = torch.load(conf.checkpoint, map_location=device)
metrics = ckpt['metrics']
agent.load_state_dict(ckpt['agent'])
memory.load_state_dict(ckpt['memory'])
policy_switch_samples = ckpt['policy_switch_samples']
total_collected_samples = ckpt['total_collected_samples']
def save_checkpoint():
# Save checkpoint
ckpt = {
'metrics': metrics,
'agent': agent.state_dict(),
'memory': memory.state_dict(),
'policy_switch_samples': policy_switch_samples,
'total_collected_samples': total_collected_samples
}
path = os.path.join(data_dir, 'checkpoint.pth')
torch.save(ckpt, path)
# Save agent model only
model_ckpt = {'agent': agent.state_dict()}
model_path = os.path.join(data_dir, 'model.pth')
torch.save(model_ckpt, model_path)
# Save metrics only
metrics_ckpt = {'metrics': metrics}
metrics_path = os.path.join(data_dir, 'metrics.pth')
torch.save(metrics_ckpt, metrics_path)
# Train agent
init_episode = 0 if len(
metrics['episode']) == 0 else metrics['episode'][-1] + 1
pbar = tqdm.tqdm(range(init_episode, conf.episodes))
reward_moving_avg = None
agent_update_count = 0
for episode in pbar:
episodic_reward = 0
o = env.reset()
q1_loss, q2_loss, policy_loss, alpha_loss, alpha = None, None, None, None, None
for t in range(conf.horizon):
if total_collected_samples <= conf.random_sample_num: # Select random actions at the begining of training.
h = env.action_space.sample()
elif memory.step <= conf.random_sample_num: # Select actions from random latent variable soon after inserting a new subpolicy.
h = agent.select_action(o, random=True)
else:
h = agent.select_action(o)
a = agent.post_process_action(
o, h) # Convert abstract action h to actual action a
o_next, r, done, _ = env.step(a)
total_collected_samples += 1
episodic_reward += r
memory.push(o, h, r, o_next, done)
o = o_next
if memory.step > conf.random_sample_num:
# Update agent
batch_data = memory.sample(conf.agent_update_batch_size)
q1_loss, q2_loss, policy_loss, alpha_loss, alpha = agent.update_parameters(
batch_data, agent_update_count)
agent_update_count += 1
if done:
break
# Describe and save episodic metrics
reward_moving_avg = (
1. - MOVING_AVG_COEF
) * reward_moving_avg + MOVING_AVG_COEF * episodic_reward if reward_moving_avg else episodic_reward
pbar.set_description(
"EPISODE {} (total samples {}, subpolicy samples {}) --- Step {}, Reward {:.1f} (avg {:.1f})"
.format(episode, total_collected_samples, memory.step, t,
episodic_reward, reward_moving_avg))
metrics['episode'].append(episode)
metrics['reward'].append(episodic_reward)
metrics['episodic_step'].append(t)
metrics['collected_total_samples'].append(total_collected_samples)
if episode % visualize_interval == 0:
# Visualize metrics
lineplot(metrics['episode'][-len(metrics['reward']):],
metrics['reward'], 'REWARD', log_dir)
reward_avg = np.array(metrics['reward']) / np.array(
metrics['episodic_step'])
lineplot(metrics['episode'][-len(reward_avg):], reward_avg,
'AVG_REWARD', log_dir)
lineplot(
metrics['collected_total_samples'][-len(metrics['reward']):],
metrics['reward'],
'SAMPLE-REWARD',
log_dir,
xaxis='sample')
# Save metrics for agent update
if q1_loss is not None:
metrics['q_loss'].append(np.mean([q1_loss, q2_loss]))
metrics['policy_loss'].append(policy_loss)
metrics['alpha_loss'].append(alpha_loss)
metrics['alpha'].append(alpha)
if episode % visualize_interval == 0:
lineplot(metrics['episode'][-len(metrics['q_loss']):],
metrics['q_loss'], 'Q_LOSS', log_dir)
lineplot(metrics['episode'][-len(metrics['policy_loss']):],
metrics['policy_loss'], 'POLICY_LOSS', log_dir)
lineplot(metrics['episode'][-len(metrics['alpha_loss']):],
metrics['alpha_loss'], 'ALPHA_LOSS', log_dir)
lineplot(metrics['episode'][-len(metrics['alpha']):],
metrics['alpha'], 'ALPHA', log_dir)
# Insert new subpolicy layer and reset memory if a specific amount of samples is collected
if policy_switch_samples and len(
policy_switch_samples
) > 0 and total_collected_samples >= policy_switch_samples[0]:
print(
"----------------------\nInser new policy\n----------------------"
)
agent.insert_subpolicy()
memory.reset()
metrics['policy_switch_epoch'].append(episode)
metrics['policy_switch_sample'].append(total_collected_samples)
policy_switch_samples = policy_switch_samples[1:]
# Test a policy
if episode % conf.test_interval == 0:
test_rewards = []
for _ in range(conf.test_times):
episodic_reward = 0
obs = env.reset()
for t in range(conf.horizon):
h = agent.select_action(obs, eval=True)
a = agent.post_process_action(o, h)
obs_next, r, done, _ = env.step(a)
episodic_reward += r
obs = obs_next
if done:
break
test_rewards.append(episodic_reward)
test_reward_avg, test_reward_std = np.mean(test_rewards), np.std(
test_rewards)
print(" TEST --- ({} episodes) Reward {:.1f} (pm {:.1f})".format(
conf.test_times, test_reward_avg, test_reward_std))
metrics['test_episode'].append(episode)
metrics['test_reward'].append(test_rewards)
lineplot(metrics['test_episode'][-len(metrics['test_reward']):],
metrics['test_reward'], "TEST_REWARD", log_dir)
# Save checkpoint
if episode % conf.checkpoint_interval:
save_checkpoint()
# Save the final model
torch.save({'agent': agent.state_dict()},
os.path.join(data_dir, 'final_model.pth'))
help='activation function of the discriminator')
parser.add_argument(
'--norm_d',
type=str,
default='bn',
help='type of the normalization used in the discriminator')
# for gan
parser.add_argument(
'--max_mult',
type=int,
default=8,
help='maximum value multiplied by the # of conv filters')
args = parser.parse_args()
args.save = args.root + '/' + args.save
utils.create_save_dir(args.save)
if args.use_wandb:
import wandb
# 추후 trainer와 model builder를 따로 만들 것
##### build
DEVICE = 'cuda'
set_randomness(args)
train_loader, test_loader = data.create_dataloader(args)
generator = models.dcgan.architecture.Generator(args)
discriminator = models.dcgan.architecture.Discriminator(args)