def step(hiddens, x): gsn = GSN(inputs_hook=(28 * 28, x), hiddens_hook=(gsn_hiddens, hiddens), params_hook=(gsn_params), **gsn_args) # return the reconstruction and cost! return gsn.get_outputs(), gsn.get_train_cost()
def step(hiddens, x): gsn = GSN( inputs_hook=(28*28, x), hiddens_hook=(gsn_hiddens, hiddens), params_hook=(gsn_params), **gsn_args ) # return the reconstruction and cost! return gsn.get_outputs(), gsn.get_train_cost()
def recurrent_step(self, x_t, u_tm1): """ Performs one timestep for recurrence. Parameters ---------- x_t : tensor The input at time t. u_tm1 : tensor The previous timestep (t-1) recurrent hiddens. Returns ------- tuple Current generated visible x_t and recurrent u_t if generating (no x_t given as parameter), otherwise current recurrent u_t and hiddens h_t. """ # If `x_t` is given, deterministic recurrence to compute the u_t. Otherwise, first generate. # Make current guess for hiddens based on U h_list = [] for i in range(self.layers): if i % 2 == 0: log.debug("Using {0!s} and {1!s}".format( self.recurrent_to_gsn_weights_list[(i+1) / 2], self.bias_list[i+1])) h = T.dot(u_tm1, self.recurrent_to_gsn_weights_list[(i+1) / 2]) + self.bias_list[i+1] h = self.hidden_activation_func(h) h_list.append(h) h_t = T.concatenate(h_list, axis=0) generate = x_t is None if generate: h_list_generate = [T.shape_padleft(h) for h in h_list] # create a GSN to generate x_t assert self.input_size, self gsn = GSN( inputs_hook = (self.input_size, self.input), input_size = self.input_size, hiddens_hook = (self.hidden_size, T.concatenate(h_list_generate, axis=1)), params_hook = self.gsn_params, outdir = os.path.join(self.outdir, 'gsn_generate/'), layers = self.layers, walkbacks = self.walkbacks, visible_activation = self.visible_activation_func, hidden_activation = self.hidden_activation_func, input_sampling = self.input_sampling, mrg = self.mrg, tied_weights = self.tied_weights, cost_function = self.cost_function, cost_args = self.cost_args, add_noise = self.add_noise, noiseless_h1 = self.noiseless_h1, hidden_noise = self.hidden_noise, hidden_noise_level = self.hidden_noise_level, input_noise = self.input_noise, input_noise_level = self.input_noise_level, noise_decay = self.noise_decay, noise_annealing = self.noise_annealing, image_width = self.image_width, image_height = self.image_height ) x_t = gsn.get_outputs().flatten() ua_t = T.dot(x_t, self.W_x_u) + T.dot(u_tm1, self.W_u_u) + self.recurrent_bias u_t = self.rnn_hidden_activation_func(ua_t) return [x_t, u_t] if generate else [u_t, h_t]
def _build_rnngsn(self): """ Creates the updates and other return variables for the computation graph. Returns ------- List the sample at the end of the computation graph, the train cost function, the train monitors, the computation updates, the generated visible list, the generated computation updates, the ending recurrent states """ # For training, the deterministic recurrence is used to compute all the # {h_t, 1 <= t <= T} given Xs. Conditional GSNs can then be trained # in batches using those parameters. (u, h_ts), updates_train = theano.scan(fn=lambda x_t, u_tm1: self.recurrent_step(x_t, u_tm1), sequences=self.input, outputs_info=[self.u0, None], name="rnngsn_computation_scan") h_list = [T.zeros_like(self.input)] for layer, w in enumerate(self.weights_list[:self.layers]): if layer % 2 != 0: h_list.append(T.zeros_like(T.dot(h_list[-1], w))) else: h_list.append((h_ts.T[(layer/2) * self.hidden_size:(layer/2 + 1) * self.hidden_size]).T) gsn = GSN( inputs_hook = (self.input_size, self.input), input_size = self.input_size, hiddens_hook = (self.hidden_size, GSN.pack_hiddens(h_list)), params_hook = self.gsn_params, outdir = os.path.join(self.outdir, 'gsn_noisy/'), layers = self.layers, walkbacks = self.walkbacks, visible_activation = self.visible_activation_func, hidden_activation = self.hidden_activation_func, input_sampling = self.input_sampling, mrg = self.mrg, tied_weights = self.tied_weights, cost_function = self.cost_function, cost_args = self.cost_args, add_noise = self.add_noise, noiseless_h1 = self.noiseless_h1, hidden_noise = self.hidden_noise, hidden_noise_level = self.hidden_noise_level, input_noise = self.input_noise, input_noise_level = self.input_noise_level, noise_decay = self.noise_decay, noise_annealing = self.noise_annealing, image_width = self.image_width, image_height = self.image_height ) cost = gsn.get_train_cost() monitors = gsn.get_monitors() # frame-level error would be the 'mse' monitor from GSN x_sample_recon = gsn.get_outputs() # symbolic loop for sequence generation (x_ts, u_ts), updates_generate = theano.scan(lambda u_tm1: self.recurrent_step(None, u_tm1), outputs_info=[None, self.generate_u0], n_steps=self.n_steps, name="rnngsn_generate_scan") return x_sample_recon, cost, monitors, updates_train, x_ts, updates_generate, u_ts[-1]
def recurrent_step(self, x_t, u_tm1): """ Performs one timestep for recurrence. Parameters ---------- x_t : tensor The input at time t. u_tm1 : tensor The previous timestep (t-1) recurrent hiddens. Returns ------- tuple Current generated visible x_t and recurrent u_t if generating (no x_t given as parameter), otherwise current recurrent u_t and hiddens h_t. """ # If `x_t` is given, deterministic recurrence to compute the u_t. Otherwise, first generate. # Make current guess for hiddens based on U h_list = [] for i in range(self.layers): if i % 2 == 0: log.debug("Using {0!s} and {1!s}".format( self.recurrent_to_gsn_weights_list[(i+1) / 2], self.bias_list[i+1])) h = T.dot(u_tm1, self.recurrent_to_gsn_weights_list[(i+1) / 2]) + self.bias_list[i+1] h = self.hidden_activation_func(h) h_list.append(h) h_t = T.concatenate(h_list, axis=0) generate = x_t is None if generate: h_list_generate = [T.shape_padleft(h) for h in h_list] # create a GSN to generate x_t gsn = GSN( inputs_hook = (self.input_size, self.input), hiddens_hook = (self.hidden_size, T.concatenate(h_list_generate, axis=1)), params_hook = self.gsn_params, outdir = os.path.join(self.outdir, 'gsn_generate/'), layers = self.layers, walkbacks = self.walkbacks, visible_activation = self.visible_activation_func, hidden_activation = self.hidden_activation_func, input_sampling = self.input_sampling, mrg = self.mrg, tied_weights = self.tied_weights, cost_function = self.cost_function, cost_args = self.cost_args, add_noise = self.add_noise, noiseless_h1 = self.noiseless_h1, hidden_noise = self.hidden_noise, hidden_noise_level = self.hidden_noise_level, input_noise = self.input_noise, input_noise_level = self.input_noise_level, noise_decay = self.noise_decay, noise_annealing = self.noise_annealing, image_width = self.image_width, image_height = self.image_height ) x_t = gsn.get_outputs().flatten() ua_t = T.dot(x_t, self.W_x_u) + T.dot(u_tm1, self.W_u_u) + self.recurrent_bias u_t = self.rnn_hidden_activation_func(ua_t) return [x_t, u_t] if generate else [u_t, h_t]
def _build_rnngsn(self): """ Creates the updates and other return variables for the computation graph. Returns ------- List the sample at the end of the computation graph, the train cost function, the train monitors, the computation updates, the generated visible list, the generated computation updates, the ending recurrent states """ # For training, the deterministic recurrence is used to compute all the # {h_t, 1 <= t <= T} given Xs. Conditional GSNs can then be trained # in batches using those parameters. (u, h_ts), updates_train = theano.scan(fn=lambda x_t, u_tm1: self.recurrent_step(x_t, u_tm1), sequences=self.input, outputs_info=[self.u0, None], name="rnngsn_computation_scan") h_list = [T.zeros_like(self.input)] for layer, w in enumerate(self.weights_list[:self.layers]): if layer % 2 != 0: h_list.append(T.zeros_like(T.dot(h_list[-1], w))) else: h_list.append((h_ts.T[(layer/2) * self.hidden_size:(layer/2 + 1) * self.hidden_size]).T) gsn = GSN( inputs_hook = (self.input_size, self.input), hiddens_hook = (self.hidden_size, GSN.pack_hiddens(h_list)), params_hook = self.gsn_params, outdir = os.path.join(self.outdir, 'gsn_noisy/'), layers = self.layers, walkbacks = self.walkbacks, visible_activation = self.visible_activation_func, hidden_activation = self.hidden_activation_func, input_sampling = self.input_sampling, mrg = self.mrg, tied_weights = self.tied_weights, cost_function = self.cost_function, cost_args = self.cost_args, add_noise = self.add_noise, noiseless_h1 = self.noiseless_h1, hidden_noise = self.hidden_noise, hidden_noise_level = self.hidden_noise_level, input_noise = self.input_noise, input_noise_level = self.input_noise_level, noise_decay = self.noise_decay, noise_annealing = self.noise_annealing, image_width = self.image_width, image_height = self.image_height ) cost = gsn.get_train_cost() monitors = gsn.get_monitors() # frame-level error would be the 'mse' monitor from GSN x_sample_recon = gsn.get_outputs() # symbolic loop for sequence generation (x_ts, u_ts), updates_generate = theano.scan(lambda u_tm1: self.recurrent_step(None, u_tm1), outputs_info=[None, self.generate_u0], n_steps=self.n_steps, name="rnngsn_generate_scan") return x_sample_recon, cost, monitors, updates_train, x_ts, updates_generate, u_ts[-1]