def fit(self, xs, ys, log=True):
if self._subsample_factor < 1:
num_samples_tot = xs.shape[0]
idx = np.random.randint(
0, num_samples_tot,
int(num_samples_tot * self._subsample_factor))
xs, ys = xs[idx], ys[idx]
if self._normalize_inputs:
# recompute normalizing constants for inputs
self._x_mean_var.set_value(
np.mean(xs, axis=0,
keepdims=True).astype(theano.config.floatX))
self._x_std_var.set_value((np.std(xs, axis=0, keepdims=True) +
1e-8).astype(theano.config.floatX))
if self._normalize_outputs:
# recompute normalizing constants for outputs
self._y_mean_var.set_value(
np.mean(ys, axis=0,
keepdims=True).astype(theano.config.floatX))
self._y_std_var.set_value((np.std(ys, axis=0, keepdims=True) +
1e-8).astype(theano.config.floatX))
if self._name:
prefix = self._name + "_"
else:
prefix = ""
# FIXME: needs batch computation to avoid OOM.
loss_before, loss_after, mean_kl, batch_count = 0., 0., 0., 0
for batch in iterate_minibatches_generic(input_lst=[xs, ys],
batchsize=self._batchsize,
shuffle=True):
batch_count += 1
xs, ys = batch
if self._use_trust_region:
old_means, old_log_stds = self._f_pdists(xs)
inputs = [xs, ys, old_means, old_log_stds]
else:
inputs = [xs, ys]
loss_before += self._optimizer.loss(inputs)
self._optimizer.optimize(inputs)
loss_after += self._optimizer.loss(inputs)
if self._use_trust_region:
mean_kl += self._optimizer.constraint_val(inputs)
if log:
logger.record_tabular(prefix + 'LossBefore',
loss_before / batch_count)
logger.record_tabular(prefix + 'LossAfter',
loss_after / batch_count)
logger.record_tabular(prefix + 'dLoss',
loss_before - loss_after / batch_count)
if self._use_trust_region:
logger.record_tabular(prefix + 'MeanKL', mean_kl / batch_count)
def fit(self, xs, ys):
if self._subsample_factor < 1:
num_samples_tot = xs.shape[0]
idx = np.random.randint(0, num_samples_tot, int(num_samples_tot * self._subsample_factor))
xs, ys = xs[idx], ys[idx]
if self._normalize_inputs:
# recompute normalizing constants for inputs
self._x_mean_var.set_value(
np.mean(xs, axis=0, keepdims=True).astype(theano.config.floatX))
self._x_std_var.set_value(
(np.std(xs, axis=0, keepdims=True) + 1e-8).astype(theano.config.floatX))
if self._normalize_outputs:
# recompute normalizing constants for outputs
self._y_mean_var.set_value(
np.mean(ys, axis=0, keepdims=True).astype(theano.config.floatX))
self._y_std_var.set_value(
(np.std(ys, axis=0, keepdims=True) + 1e-8).astype(theano.config.floatX))
if self._name:
prefix = self._name + "_"
else:
prefix = ""
# FIXME: needs batch computation to avoid OOM.
loss_before, loss_after, mean_kl, batch_count = 0., 0., 0., 0
for batch in iterate_minibatches_generic(input_lst=[xs, ys], batchsize=self._batchsize, shuffle=True):
batch_count += 1
xs, ys = batch
if self._use_trust_region:
old_means, old_log_stds = self._f_pdists(xs)
inputs = [xs, ys, old_means, old_log_stds]
else:
inputs = [xs, ys]
loss_before += self._optimizer.loss(inputs)
self._optimizer.optimize(inputs)
loss_after += self._optimizer.loss(inputs)
if self._use_trust_region:
mean_kl += self._optimizer.constraint_val(inputs)
logger.record_tabular(prefix + 'LossBefore', loss_before / batch_count)
logger.record_tabular(prefix + 'LossAfter', loss_after / batch_count)
logger.record_tabular(prefix + 'dLoss', loss_before - loss_after / batch_count)
if self._use_trust_region:
logger.record_tabular(prefix + 'MeanKL', mean_kl / batch_count)
def fit(self, xs, ys):
shareds, barriers = self._par_objs
# report sample sizes
n_steps_collected = xs.shape[0]
shareds.n_steps_collected[self.rank] = n_steps_collected
self._optimizer.set_avg_fac(n_steps_collected)
total_n_steps_collected = np.sum(shareds.n_steps_collected)
if self._subsample_factor < 1:
idx = np.random.randint(
0, n_steps_collected,
int(n_steps_collected * self._subsample_factor))
xs, ys = xs[idx], ys[idx]
""" the only change in parallel version """
if self._normalize_inputs:
# each worker computes its statistics
input_dim = np.prod(self.input_shape)
x_sum = np.sum(xs, axis=0, keepdims=False).reshape(input_dim)
x_square_sum = np.sum(xs**2, axis=0,
keepdims=False).reshape(input_dim)
shareds.x_sum_2d[:, self.rank] = x_sum
shareds.x_square_sum_2d[:, self.rank] = x_square_sum
barriers.normalize_inputs[0].wait()
# sum up statistics from different workers
# currently this is performed by all workers
x_mean = np.sum(shareds.x_sum_2d, axis=1) / total_n_steps_collected
x_square_mean = np.sum(shareds.x_square_sum_2d,
axis=1) / total_n_steps_collected
x_std = np.sqrt(x_square_mean - x_mean**2 + 1e-8)
# prepare for NN to use
self._x_mean_var.set_value(
x_mean.reshape((1, -1)).astype(theano.config.floatX))
self._x_std_var.set_value(
x_std.reshape((1, -1)).astype(theano.config.floatX))
barriers.normalize_inputs[1].wait()
if self._normalize_outputs:
# each worker computes its statistics
output_dim = self.output_dim
y_sum = np.sum(ys, axis=0, keepdims=False).reshape(output_dim)
y_square_sum = np.sum(ys**2, axis=0,
keepdims=False).reshape(output_dim)
shareds.y_sum_2d[:, self.rank] = y_sum
shareds.y_square_sum_2d[:, self.rank] = y_square_sum
barriers.normalize_outputs[0].wait()
# sum up statistics from different workers
# currently this is performed by all workers
y_mean = np.sum(shareds.y_sum_2d, axis=1) / total_n_steps_collected
y_square_mean = np.sum(shareds.y_square_sum_2d,
axis=1) / total_n_steps_collected
y_std = np.sqrt(y_square_mean - y_mean**2 + 1e-8)
# prepare for NN to use
self._y_mean_var.set_value(
y_mean.reshape((1, -1)).astype(theano.config.floatX))
self._y_std_var.set_value(
y_std.reshape((1, -1)).astype(theano.config.floatX))
# DEBUG: check whether the normalization is correct
# print(y_sum / n_steps_collected, y_mean,np.std(ys), y_std)
barriers.normalize_outputs[1].wait()
"""""" """""" """""" """""" """""" """"""
if self._name:
prefix = self._name + "_"
else:
prefix = ""
# FIXME: needs batch computation to avoid OOM.
loss_before, loss_after, mean_kl, batch_count = 0., 0., 0., 0
for batch in iterate_minibatches_generic(input_lst=[xs, ys],
batchsize=self._batchsize,
shuffle=True):
batch_count += 1
_xs, _ys = batch
if self._use_trust_region:
old_means, old_log_stds = self._f_pdists(_xs)
inputs = [_xs, _ys, old_means, old_log_stds]
else:
inputs = [_xs, _ys]
loss_before += self._optimizer._loss(inputs, extra_inputs=None)
self._optimizer.optimize(inputs)
loss_after += self._optimizer._loss(inputs, extra_inputs=None)
if self._use_trust_region:
mean_kl += self._optimizer._constraint_val(inputs,
extra_inputs=None)
logger.record_tabular(prefix + 'LossBefore', loss_before / batch_count)
logger.record_tabular(prefix + 'LossAfter', loss_after / batch_count)
logger.record_tabular(prefix + 'dLoss',
(loss_before - loss_after) / batch_count)
if self._use_trust_region:
logger.record_tabular(prefix + 'MeanKL', mean_kl / batch_count)
def fit(self, xs, ys):
if self._subsample_factor < 1:
num_samples_tot = xs.shape[0]
idx = np.random.randint(
0, num_samples_tot,
int(num_samples_tot * self._subsample_factor))
xs, ys = xs[idx], ys[idx]
if self._normalize_inputs:
# recompute normalizing constants for inputs
self._x_mean_var.set_value(
np.mean(xs, axis=0,
keepdims=True).astype(theano.config.floatX))
self._x_std_var.set_value((np.std(xs, axis=0, keepdims=True) +
1e-8).astype(theano.config.floatX))
if self._normalize_outputs:
# recompute normalizing constants for outputs
self._y_mean_var.set_value(
np.mean(ys, axis=0,
keepdims=True).astype(theano.config.floatX))
self._y_std_var.set_value((np.std(ys, axis=0, keepdims=True) +
1e-8).astype(theano.config.floatX))
if self._name:
prefix = self._name + "_"
else:
prefix = ""
# FIXME: needs batch computation to avoid OOM.
loss_before, loss_after, mean_kl, batch_count = 0., 0., 0., 0
for batch in iterate_minibatches_generic(input_lst=[xs, ys],
batchsize=self._batchsize,
shuffle=True):
batch_count += 1
xs, ys = batch
if self._use_trust_region:
old_means, old_log_stds = self._f_pdists(xs)
inputs = [xs, ys, old_means, old_log_stds]
else:
inputs = [xs, ys]
loss_before_cur = self._optimizer.loss(inputs)
# saving parameters to reverse in case of Nan problem
params_before_optimization = copy.deepcopy(
self._optimizer._target.get_param_values(
trainable=True).astype('float64'))
self._optimizer.optimize(inputs)
loss_after_cur = self._optimizer.loss(inputs)
if (not math.isnan(loss_after_cur)) and \
(not math.isinf(loss_after_cur)):
loss_after += loss_after_cur
loss_before += loss_before_cur
if self._use_trust_region:
mean_kl += self._optimizer.constraint_val(inputs)
else: #reversing for this particular batch
batch_count -= 1 #to remove failure batch
batch_str = str(inputs) + '\n'
#Documenting error
with open(self.error_file, "a") as myfile:
myfile.write(batch_str)
#Reversing optimized parameters
self._optimizer._target.set_param_values(
params_before_optimization, trainable=True)
print(
'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
)
print('ERROR: Nans appear. Parameters reversed to: ',
params_before_optimization)
if batch_count == 0:
# to avoid devision by 0 and getting Nans
batch_count = 1
logger.record_tabular(prefix + 'LossBefore', loss_before / batch_count)
logger.record_tabular(prefix + 'LossAfter', loss_after / batch_count)
logger.record_tabular(prefix + 'dLoss',
loss_before - loss_after / batch_count)
if self._use_trust_region:
logger.record_tabular(prefix + 'MeanKL', mean_kl / batch_count)
