def fit(self, inputs, target, epochs): for i in range(epochs): with self.train(): value = self.forward(inputs) loss = rm.mean_squared_error(value, target) loss.grad().update(rm.Adam(lr=0.001)) return loss
def test_gpu_node_mean_squared_error(a, b): set_cuda_active(True) g1 = Variable(a) g2 = Variable(b) g3 = rm.mean_squared_error(g1, g2) g = g3.grad() g_g1 = g.get(g1) g3.to_cpu() g_g1.to_cpu() set_cuda_active(False) c3 = rm.mean_squared_error(g1, g2) c = c3.grad() c_g1 = c.get(g1) close(g3, c3) close(c_g1, g_g1)
def forward(self, x, eps=1e-3): nb = len(x) self.enc(x) e = np.random.randn(nb, self.latent_dim) self.z = self.enc.zm + rm.exp(self.enc.zlv / 2) * e self.decd = self.dec(self.z) self.reconE = rm.mean_squared_error(self.decd, x) self.kl_loss = -0.5 * rm.sum(1 + self.enc.zlv - self.enc.zm**2 - rm.exp(self.enc.zlv)) / nb return self.decd
def forward(self, x): self.z_mean, self.z_log_var = self.enc(x) e = np.random.randn(len(x), self.latent_dim) * 1. z_new = self.z_mean + rm.exp(self.z_log_var / 2) * e self.decoded = self.dec(z_new) nb, zd = self.z_log_var.shape self.kl_loss = -0.5 * rm.sum(1 + self.z_log_var - self.z_mean**2 - rm.exp(self.z_log_var)) / nb #self.recon_loss = rm.sigmoid_cross_entropy(self.decoded, x) self.recon_loss = rm.mean_squared_error(self.decoded, x) vae_loss = self.kl_loss + self.recon_loss return vae_loss
def forward(self, x, perm, y=None, opt=None): n = len(x) output_shape = self.arch['output_shape'] batch_input_shape = self.get_shape(self.batch, self.arch['input_shape']) batch_output_shape = self.get_shape(self.batch, output_shape) pred_output_shape = self.get_shape(n, output_shape) if opt is None or y is None: self._set_inference(True) #self._model.set_models(inference=True) history = [] pred = np.zeros(pred_output_shape) _batch = self.batch for i in np.arange(0, n, _batch): _idx = perm[i:i + _batch] _batch_x = np.zeros(batch_input_shape) _batch_x[:len(_idx)] = x[_idx] if not y is None: _batch_y = y[_idx] if opt is None or y is None: z = self._forward(_batch_x) if not y is None: loss = rm.mean_squared_error(z[:len(_idx)], _batch_y) else: z, loss = self._train(_batch_x, _idx, _batch_y) if 0: with self._train(): #_model.train(): z = self._forward(_batch_x) loss = rm.mean_squared_error(z[:len(_idx)], _batch_y) grad = loss.grad() grad.update(opt) if not y is None: history.append(loss.as_ndarray()) pred[_idx] = z[:len(_idx)].as_ndarray() #self._model.set_models(inference=False) self._set_inference(False) if y is None: return pred return np.array(history)
def forward(self, x, eps=1e-3): nb = len(x) self.z_mu = self.enc(x) self.decd = self.dec(self.z_mu) self.reconE = rm.mean_squared_error(self.decd, x) return self.decd
def func(node, x): return sum(rm.mean_squared_error(node, x, reduce_sum=False))
def func(node, x): return rm.mean_squared_error(node, x)
figsize=(8, epoch_splits*4)) if batch_size == 'Full': batch_size = len(train_x) curve = [[], []] neighbor_period = [] for e in range(epoch): s = time() perm = np.random.permutation(len(train_x)) batch_loss = [] for i in range(0, len(train_x), batch_size): idx = perm[i:i+batch_size] batch_x = train_x[idx] batch_y = train_y[idx] with func_model.train(): loss = rm.mean_squared_error(func_model(batch_x), batch_y) grad = loss.grad() grad.update(optimizer) batch_loss.append(loss.as_ndarray()) neighbor_period.append(time()-s) curve[0].append(np.array(batch_loss).mean()) loss = rm.mean_squared_error(func_model(test_x), test_y) curve[1].append(loss.as_ndarray()) if e % epoch_period == epoch_period - 1 or e == epoch: current_period = np.array(neighbor_period).mean() neighbor_period = [] ax_ = ax[e//epoch_period] curve_na = np.array(curve) ax_[0].text(0,0.5, '{:.2f}sec @ epoch'.format(current_period)) ax_[0].plot(curve_na[0]) ax_[0].plot(curve_na[1])
def _train(self, x, idx, y): with self.fcnn.train(): x = self.fcnn(x) z = rm.reshape(x, self.batch_output_shape) return z, rm.mean_squared_error(z[:len(idx)], y)
def forward(self, x, y=None, eps=1e-3): # x : input data # y : one-hot label data for categorical dist. or supporting dis. # empty is not assignment # self.qzx : style z # self.rep : input data for decoding nb = len(x) # --- encoding phase --- if 0: noise = random.randn(x.size).reshape(nb, x.shape[1])*0.03 self._x = x+noise else: _x = x if self.mode=='clustering' or self.mode=='reduction': self.qzx, self.qyx = self.enc(_x) else: self.qzx = self.enc(_x) # --- decoding/reconstruction phase --- if self.mode=='clustering' or self.mode=='reduction': self.recon = self.dec(rm.concat(self.qzx, self.qyx)) else: self.recon = self.dec(self.qzx) # --- reguralization phase --- if self.mode == 'incorp_label': self._set_incorpdist(x) else: self._set_distribution(x) if self.mode == 'clustering': "categorical dist" elif self.mode == 'supervised': "" elif self.mode == 'dim_reduction': "" if self.mode == 'incorp_label': self._incorp_label(x, y, eps=eps) else: self.Dpz = self.dis(self.pz) self.Dqzx = self.dis(self.qzx) self.real = -rm.sum(rm.log( self.Dpz + eps ))/nb self.fake = -rm.sum(rm.log( 1 - self.Dqzx + eps ))/nb self.fake2pos = -rm.sum(rm.log( self.Dqzx + eps ))/nb if self.mode=='clustering' or self.mode=='reduction': _idx = np.where(y.sum(1)==1)[0] idx_ = np.where(y.sum(1)==0)[0] if len(_idx) > 0: self.Cy = self.cds(y) self.Cqyx = self.cds(self.qyx) self.Creal = -rm.sum(rm.log( self.Cy[_idx] + eps ))/len(_idx) if 0: self.Cfake = -rm.sum(rm.log( 1 - self.Cqyx[_idx] + eps ))/len(_idx) else: self.Cfake = -rm.sum(rm.log( 1 - self.Cqyx + eps ))/nb self.Cfake2 = -rm.sum(rm.log( self.Cqyx[_idx] + eps ))/len(_idx) else: self.Cfake = rm.Variable(0) self.Creal = rm.Variable(0) self.Cfake2 = rm.Variable(0) # --- sumalizing loss --- self.gan_loss = self.real + self.fake if self.mode=='clustering': if len(_idx) > 0: self.reconE = rm.mean_squared_error( self.recon[idx_], x[idx_]) else: self.reconE = rm.mean_squared_error(self.recon, x) else: self.reconE = rm.mean_squared_error(self.recon, x) self.real_count = (self.Dpz >= 0.5).sum()/nb self.fake_count = (self.Dqzx < 0.5).sum()/nb self.enc_loss = self.fake2pos if self.mode=='clustering' or self.mode=='reduction': if len(_idx) > 0: self.Creal_count = (self.Cy[_idx] >= 0.5).sum()/len(_idx) self.Cfake_count = (self.Cqyx[_idx] < 0.5).sum()/len(_idx) else: self.Creal_count = 0 self.Cfake_count = 0 self.CganE = self.Creal + self.Cfake self.CgenE = self.Cfake2 return self.recon
test_y = y_axis[test_idx] seq_model = rm.Sequential( [rm.Dense(1), rm.Dense(10), rm.Sigmoid(), rm.Dense(1)]) optimizer = rm.Sgd(0.1, momentum=0.5) plt.clf() epoch_splits = 10 epoch_period = epoch // epoch_splits fig, ax = plt.subplots(epoch_splits, 2, figsize=(4, epoch_splits)) curve = [[], []] for e in range(epoch): with seq_model.train(): loss = rm.mean_squared_error(seq_model(train_x), train_y) grad = loss.grad() grad.update(optimizer) curve[0].append(loss.as_ndarray()) loss = rm.mean_squared_error(seq_model(test_x), test_y) curve[1].append(loss.as_ndarray()) if e % epoch_period == epoch_period - 1 or e == epoch: ax_ = ax[e // epoch_period] curve_na = np.array(curve) ax_[0].plot(curve_na[0]) ax_[0].plot(curve_na[1]) pred_train = seq_model(train_x) pred_test = seq_model(test_x) ax_[1].plot(x_axis, base, 'k-') ax_[1].scatter(x_axis, y_axis, marker='+') ax_[1].scatter(train_x, pred_train, c='g', alpha=0.3)