class_docstr: This class enables to initialize electron's position using gauss distribution around a nucleus and update using Markov Chain Monte-Carlo(MCMC) moves.
  
  Using the probability obtained from the square of magnitude of wavefunction of a molecule/atom, MCMC steps can be performed to get the electron's positions and further update the wavefunction.
  This method is primarily used in methods like Variational Monte Carlo to sample electrons around the nucleons.
  Sampling can be done in 2 ways:
  -Simultaneous: All the electrons' positions are updated all at once.
  
  -Single-electron: MCMC steps are performed only a particular electron, given their index value.
  
  Further these moves can be done in 2 methods:
  -Symmetric: In this configuration, the standard deviation for all the steps are uniform.
  
  -Asymmetric: In this configuration, the standard deviation are not uniform and typically the standard deviation is obtained a function like harmonic distances, etc.
  
  Irrespective of these methods, the initialization is done uniformly around the respective nucleus and the number of electrons specified.
  
  Example
  -------
  >>> from deepchem.utils.electron_sampler import ElectronSampler
  >>> test_f = lambda x: 2*np.log(np.random.uniform(low=0,high=1.0,size=np.shape(x)[0]))
  >>> distribution=ElectronSampler(central_value=np.array([[1,1,3],[3,2,3]]),f=test_f,seed=0,batch_no=2,steps=1000,)
  >>> distribution.gauss_initialize_position(np.array([[1],[2]]))
  
  >> print(distribution.x)
  [[[[1.03528105 1.00800314 3.01957476]]
  
    [[3.01900177 1.99697286 2.99793562]]
  
    [[3.00821197 2.00288087 3.02908547]]]
  
  
  [[[1.04481786 1.03735116 2.98045444]]
  
    [[3.01522075 2.0024335  3.00887726]]
  
    [[3.00667349 2.02988158 2.99589683]]]]
  >>> distribution.move()
  0.5115
  
  >> print(distribution.x)
  [[[[-0.32441754  1.23330263  2.67927645]]
  
    [[ 3.42250997  2.23617126  3.55806632]]
  
    [[ 3.37491385  1.54374006  3.13575241]]]
  
  
  [[[ 0.49067726  1.03987841  3.70277884]]
  
    [[ 3.5631939   1.68703947  2.5685874 ]]
  
    [[ 2.84560249  1.73998364  3.41274181]]]]
docstr: Performs Metropolis-Hasting move for self.x(electrons). The type of moves to be followed -(simultaneous or single-electron, symmetric or asymmetric) have been specified when calling the class.
  The self.x array is replaced with a new array at the end of each step containing the new electron's positions.
  
  Parameters
  ----------
  asymmetric_func: Callable[[np.ndarray],np.ndarray], optional(default None)
      Should be specified for an asymmetric move.The function should take in only 1 argument- y: a numpy array wrt to which mean should be calculated.
      This function should return the mean for the asymmetric proposal. For ferminet, this function is the harmonic mean of the distance between the electron and the nucleus.
  stddev: float, optional (default 0.02)
      Specifies the standard deviation in the case of symmetric moves and the scaling factor of the standard deviation matrix in the case of asymmetric moves.
  index: int, optional (default None)
      Specifies the index of the electron to be updated in the case of a single electron move.
  
  Returns
  -------
  float
      accepted move ratio of the MCMC steps.
docstr_tok: ["Performs","Metropolis-Hasting","move","for","self.x","(","electrons",")",".","The","type","of","moves","to","be","followed","-","(","simultaneous","or","single-electron",",","symmetric","or","asymmetric",")","have","been","specified","when","calling","the","class",".","The","self.x","array","is","replaced","with","a","new","array","at","the","end","of","each","step","containing","the","new","electron","'s","positions",".","Parameters","--","--","--","--","--","asymmetric_func",":","Callable","[","[","np.ndarray","]",",","np.ndarray","]",",","optional","(","default","None",")","Should","be","specified","for","an","asymmetric","move.The","function","should","take","in","only","1","argument-","y",":","a","numpy","array","wrt","to","which","mean","should","be","calculated",".","This","function","should","return","the","mean","for","the","asymmetric","proposal",".","For","ferminet",",","this","function","is","the","harmonic","mean","of","the","distance","between","the","electron","and","the","nucleus",".","stddev",":","float",",","optional","(","default","0.02",")","Specifies","the","standard","deviation","in","the","case","of","symmetric","moves","and","the","scaling","factor","of","the","standard","deviation","matrix","in","the","case","of","asymmetric","moves",".","index",":","int",",","optional","(","default","None",")","Specifies","the","index","of","the","electron","to","be","updated","in","the","case","of","a","single","electron","move",".","Returns","--","--","--","-","float","accepted","move","ratio","of","the","MCMC","steps","."]
code: def move(
      self,
      stddev: float = 0.02,
      asymmetric_func: Optional[
          Callable[[np.ndarray], np.ndarray]
      ] = None,
      index: Optional[int] = None,
  ) -> float:
      """Performs Metropolis-Hasting move for self.x(electrons). The type of moves to be followed -(simultaneous or single-electron, symmetric or asymmetric) have been specified when calling the class.
      The self.x array is replaced with a new array at the end of each step containing the new electron's positions.
  
      Parameters
      ----------
      asymmetric_func: Callable[[np.ndarray],np.ndarray], optional(default None)
          Should be specified for an asymmetric move.The function should take in only 1 argument- y: a numpy array wrt to which mean should be calculated.
          This function should return the mean for the asymmetric proposal. For ferminet, this function is the harmonic mean of the distance between the electron and the nucleus.
      stddev: float, optional (default 0.02)
          Specifies the standard deviation in the case of symmetric moves and the scaling factor of the standard deviation matrix in the case of asymmetric moves.
      index: int, optional (default None)
          Specifies the index of the electron to be updated in the case of a single electron move.
  
      Returns
      -------
      float
          accepted move ratio of the MCMC steps.
      """
      self.sampled_electrons = np.array([])
  
      lp1 = self.f(self.x)  # log probability of self.x state
  
      if self.simultaneous:
          if self.symmetric:
              for i in range(self.steps):
                  x2 = np.random.normal(self.x, stddev, self.x.shape)
                  lp2 = self.f(x2)  # log probability of x2 state
                  move_prob = np.log(
                      np.random.uniform(
                          low=0, high=1.0, size=np.shape(self.x)[0]
                      )
                  )
                  ratio = lp2 - lp1
                  lp1 = self.electron_update(
                      lp1, lp2, move_prob, ratio, x2
                  )
  
          elif asymmetric_func is not None:
              for i in range(self.steps):
                  std = stddev * asymmetric_func(self.x)
                  x2 = np.random.normal(self.x, std, self.x.shape)
                  lp2 = self.f(x2)  # log probability of x2 state
                  lq1 = self.log_prob_gaussian(
                      self.x, x2, std
                  )  # forward probability
                  lq2 = self.log_prob_gaussian(
                      x2, self.x, stddev * asymmetric_func(x2)
                  )  # backward probability
                  ratio = lp2 + lq2 - lq1 - lp1
                  move_prob = np.log(
                      np.random.uniform(
                          low=0, high=1.0, size=np.shape(self.x)[0]
                      )
                  )
                  lp1 = self.electron_update(
                      lp1, lp2, move_prob, ratio, x2
                  )
  
      elif index is not None:
          index = int(index)
          x2 = np.copy(self.x)
          altered_shape = (self.batch_no, 1, np.shape(self.x)[3])
  
          if self.symmetric:
              for i in range(self.steps):
                  x2[:, index, :, :] = np.random.normal(
                      x2[:, index, :, :], stddev, size=altered_shape
                  )
                  lp2 = self.f(x2)  # log probability of x2 state
                  ratio = lp2 - lp1
                  move_prob = np.log(
                      np.random.uniform(
                          low=0, high=1.0, size=np.shape(self.x)[0]
                      )
                  )
                  lp1 = self.electron_update(
                      lp1, lp2, move_prob, ratio, x2
                  )
  
          elif asymmetric_func is not None:
              init_dev = stddev * asymmetric_func(
                  self.x
              )  # initial standard deviation matrix
              for i in range(self.steps):
                  std = stddev * asymmetric_func(self.x[:, index, :, :])
                  x2[:, index, :, :] = np.random.normal(
                      x2[:, index, :, :], std, size=altered_shape
                  )
                  lp2 = self.f(x2)  # log probability of x2 state
                  init_dev[:, index, :, :] = std
                  lq1 = self.log_prob_gaussian(
                      self.x, x2, init_dev
                  )  # forward probability
                  lq2 = self.log_prob_gaussian(
                      x2, self.x, stddev * asymmetric_func(x2)
                  )  # backward probability
                  ratio = lp2 + lq2 - lq1 - lp1
                  move_prob = np.log(
                      np.random.uniform(
                          low=0, high=1.0, size=np.shape(self.x)[0]
                      )
                  )
                  lp1 = self.electron_update(
                      lp1, lp2, move_prob, ratio, x2
                  )
  
      return self.num_accept / ((i + 1) * np.shape(self.x)[0])
  
file_path: deepchem/deepchem/utils/electron_sampler.py
imports: import numpy
  from typing import Optional, Callable
label_desc: Use image node_id 6 for calling the ElectronSampler obj's underlying member method code with example usage: obj.move(stddev, asymmetric_func, index) and returns: unknown