Reset the environment.

    Returns:
      Tensor of the current observation.
198289
def reset(self):
    
    observ_dtype = self._parse_dtype(self._env.observation_space)
    observ = tf.py_func(self._env.reset, [], observ_dtype, name='reset')
    observ = tf.check_numerics(observ, 'observ')
    with tf.control_dependencies([
        self._observ.assign(observ),
        self._reward.assign(0),
        self._done.assign(False)]):
      return tf.identity(observ)
1119043
def _reset_non_empty(self, indices):
    
    reset_video_op = tf.cond(
        self._video_condition,
        lambda: tf.py_func(self._video_reset_writer, [], []),
        tf.no_op)
    with tf.control_dependencies([reset_video_op]):
      inc_op = tf.assign_add(self._episode_counter, 1)
      with tf.control_dependencies([self.history_buffer.reset(indices),
                                    inc_op]):
        initial_frame_dump_op = tf.cond(
            self._video_condition,
            lambda: tf.py_func(self._video_dump_frames,  # pylint: disable=g-long-lambda
                               [self.history_buffer.get_all_elements()], []),
            tf.no_op)
        observ_assign_op = self._observ.assign(
            self.history_buffer.get_all_elements()[:, -1, ...])
        with tf.control_dependencies([observ_assign_op, initial_frame_dump_op]):
          reset_model_op = tf.assign(self._reset_model, tf.constant(1.0))
          with tf.control_dependencies([reset_model_op]):
            return tf.gather(self._observ.read_value(), indices)
164755
def reset(self):
        ""
        self.hidden = [next(self.parameters()).data.new(0) for i in range(self.n_layers+1)]
778627
def reset(self, dim):
        
        if self.dim != dim:
            self.dim = dim
            self.normals = self.rand.randn(self.projection_count, dim)
1085718
def reset_uniforms(self):
        
        self.uniforms['model_matrix'] = self.model_matrix_global.view()
        self.uniforms['normal_matrix'] = self.normal_matrix_global.view()
1111189
def reset(self):
        """"""
        import tqdm
        self.iter = 0
        self.pbar = tqdm.tqdm(total=self.niter, **self.kwargs)
575546
def reset(self):
        
        self.__matrix = np.array([])
        self.__networks = np.array([])
636112
def _reset_internal(self):
        
        super()._reset_internal()

        # reset positions of objects
        self.model.place_objects()

        # reset joint positions
        init_pos = np.array([-0.5538, -0.8208, 0.4155, 1.8409, -0.4955, 0.6482, 1.9628])
        init_pos += np.random.randn(init_pos.shape[0]) * 0.02
        self.sim.data.qpos[self._ref_joint_pos_indexes] = np.array(init_pos)
419722
def revert(self):
        
        os.environ.clear()
        os.environ.update(self.original)
576215
def reset(self):
        
        self._TP = np.zeros(self._n_class)
        self._FP = np.zeros(self._n_class)
        self._FN = np.zeros(self._n_class)
        self._TN = np.zeros(self._n_class)
        self.t_ = 0
        self._queried_oracle = np.repeat(False, self._max_iter)
        self.cached_labels_ = np.repeat(np.nan, self._n_items)
        self._estimate = np.tile(np.nan, [self._max_iter, self._n_class])
1009662
def _reset_model(self, response):
        """"""

        # pylint: disable=no-member

        # Reset the model to the initial state
        self._provision_done = False    # Set back the provision flag
        self._changes.clear()           # Clear the changes

        # Process the raw data from the update response
        fields = self.process_raw_data(response)
        # Update the current model representation
        self._set_fields(fields)

        # Lock the current model
        self._provision_done = True
942537
def reset(self):
        
        """
        self['pore.invasion_pressure'] = np.inf
        self['throat.invasion_pressure'] = np.inf
        self['pore.invasion_sequence'] = -1
        self['throat.invasion_sequence'] = -1
        self['pore.invasion_saturation'] = -1
        self['throat.invasion_saturation'] = -1
        self['pore.cluster'] = -1
        self['throat.cluster'] = -1
        self['pore.trapped'] = np.inf
        self['throat.trapped'] = np.inf
        self['pore.inlets'] = False
        self['pore.outlets'] = False
        self['pore.residual'] = False
        self['throat.residual'] = False
        for elem in ['pore', 'throat']:
            for prop in ['occupancy']:
                try:
                    del self[elem+'.'+prop]
                except KeyError:
                    pass

        # Masks for tracking pores and throats at the interface
        # Basically a quick way of getting to all the elements in the queues
        self._interface_Ts = np.zeros(self.Nt, dtype=bool)
        self._interface_Ps = np.zeros(self.Np, dtype=bool)
140215
def reset(self):
    """"""
    self._episode_steps = 0
    if self._episode_count:
      # No need to restart for the first episode.
      self._restart()

    self._episode_count += 1
    logging.info("Starting episode: %s", self._episode_count)
    self._metrics.increment_episode()

    self._last_score = [0] * self._num_agents
    self._state = environment.StepType.FIRST
    if self._realtime:
      self._last_step_time = time.time()
      self._target_step = 0

    return self._observe()
384450
def reset(self):
        
        self.X = []
        self.Y = []
        self.w = []

        self.Xnorm = []

        self.graph_rep = None
420694
def reset_state(self):
        """"""
        self.y = self.y0.copy()
        self.dy = np.zeros(self.dmps)   
        self.ddy = np.zeros(self.dmps)  
        self.cs.reset_state()
738908
def reset!
      self.client_id     = ENV['FIXER_CLIENT_ID']
      self.client_secret = ENV['FIXER_CLIENT_SECRET']
      self.adapter       = DEFAULT_ADAPTER
      self.endpoint      = ENV['FIXER_ENDPOINT'] || DEFAULT_ENDPOINT
      self.user_agent    = DEFAULT_USER_AGENT
      self.aws           = nil
      self.queue         = ENV['FIXER_QUEUE'] || DEFAULT_QUEUE
      self
    end
487800
def reset(self):
        ""
        [r.reset() for r in self.rnns if hasattr(r, 'reset')]
        if self.qrnn: self.hidden = [self._one_hidden(l) for l in range(self.n_layers)]
        else: self.hidden = [(self._one_hidden(l), self._one_hidden(l)) for l in range(self.n_layers)]