Reset the hidden states.
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)]
527245
private function reset() : void
    {
        $this->content = [];

        $this->scheme = null;
        $this->brand_label = null;
        $this->brand_uri = null;
    }
1191984
def hard_reset(self):
        """"""
        if self.shuffle:
            self._shuffle_data()
        self.cursor = -self.batch_size
        self._cache_data = None
        self._cache_label = None
954403
def reset(self):
        
        self.wf.fill(0)
        self.wf[(0,) * self.n_qubits] = complex(1.0, 0)
        return self
66993
def reset(self):
        """"""
        self.data     = []
        self.size     = 0
        self.kdtree   = None  # KDTree
        self.nn_ready = False
594195
def reset(self):
        '''
        
        '''
        self.resetRNG()
        sNow = np.zeros(self.pop_size)
        Shk  = self.RNG.rand(self.pop_size)
        sNow[Shk < self.p_init] = 1
        self.sNow = sNow
1347950
def _reset_state(self):
        """"""
        self._uuid = None
        self._columns = None
        self._rownumber = 0
        # Internal helper state
        self._state = self._STATE_NONE
        self._data = None
        self._columns = None
1184562
def _reset(self):
        """"""
        self.nr_of_executed_insns = 0
        self.begin = None
        self.end = None
        self.coverage = {}
415429
def reset_params(self):
        """"""
        units = [N_FEATURES]
        units += [self.hidden_units] * self.num_hidden
        units += [N_CLASSES]

        sequence = []
        for u0, u1 in zip(units, units[1:]):
            sequence.append(nn.Linear(u0, u1))
            sequence.append(self.nonlin)
            sequence.append(nn.Dropout(self.dropout))

        sequence = sequence[:-2]
        self.sequential = nn.Sequential(*sequence)
563155
def reset_training_state(self, dones, batch_info):
        
        for idx, done in enumerate(dones):
            if done > 0.5:
                self.processes[idx].reset()
1272730
def reset(self):
        """"""
        self.idx_chan.clear()
        if self.scene is not None:
            self.scene.clear()
        self.scene = None
1038858
public function resetState()
	{
		// clean states
		$this->setStateArray( new StateArray() );
		$state_array = $this->getStateArray();
		$state_array->append( new $this->initial_state );
		Session::put($this->session_key,$state_array);
	}
789269
def reset(self):
        
        self.solved = False
        self.niter = 0
        self.iter_mis = []
        self.F = None
        self.system.dae.factorize = True
355464
def reset(self):
        """"""
        self._sampled = [np.repeat(False, x) for x in self.sizes_]
        self._n_sampled = np.zeros(self.n_strata_, dtype=int)
710157
def reset(self):
        
        for ents in self.__entity_set_map.values():
            for ent in ents:
                EntityState.release(ent, self)
        self.__entity_set_map.clear()
296808
def reset(self):
        """"""
        self.filename = None
        self.groups = []

        self.tabs.clear()

        self.setEnabled(False)
        self.button_color.setEnabled(False)
        self.button_del.setEnabled(False)
        self.button_apply.setEnabled(False)
        self.action['load_channels'].setEnabled(False)
        self.action['save_channels'].setEnabled(False)
1111189
def reset(self):
        """"""
        import tqdm
        self.iter = 0
        self.pbar = tqdm.tqdm(total=self.niter, **self.kwargs)