code: def build_model(self, n_features, regtype='none'):
          
          self._create_placeholders(n_features)
          self._create_variables(n_features)
          self.encode = self.sample_hidden_from_visible(self.input_data)[0]
          self.reconstruction = self.sample_visible_from_hidden(
              self.encode, n_features)
  
          hprob0, hstate0, vprob, hprob1, hstate1 = self.gibbs_sampling_step(
              self.input_data, n_features)
          positive = self.compute_positive_association(self.input_data,
                                                       hprob0, hstate0)
  
          nn_input = vprob
  
          for step in range(self.gibbs_sampling_steps - 1):
              hprob, hstate, vprob, hprob1, hstate1 = self.gibbs_sampling_step(
                  nn_input, n_features)
              nn_input = vprob
  
          negative = tf.matmul(tf.transpose(vprob), hprob1)
  
          self.w_upd8 = self.W.assign_add(
              self.learning_rate * (positive - negative) / self.batch_size)
  
          self.bh_upd8 = self.bh_.assign_add(tf.multiply(self.learning_rate, tf.reduce_mean(
              tf.subtract(hprob0, hprob1), 0)))
  
          self.bv_upd8 = self.bv_.assign_add(tf.multiply(self.learning_rate, tf.reduce_mean(
              tf.subtract(self.input_data, vprob), 0)))
  
          variables = [self.W, self.bh_, self.bv_]
          regterm = Layers.regularization(variables, self.regtype, self.regcoef)
  
          self.cost = self.loss.compile(vprob, self.input_data, regterm=regterm)
docs: Build the Restricted Boltzmann Machine model in TensorFlow.
  
          :param n_features: number of features
          :param regtype: regularization type
          :return: self