class_docstr: Gaussian process classification (GPC) based on Laplace approximation.
  
  The implementation is based on Algorithm 3.1, 3.2, and 5.1 of
  Gaussian Processes for Machine Learning (GPML) by Rasmussen and
  Williams.
  
  Internally, the Laplace approximation is used for approximating the
  non-Gaussian posterior by a Gaussian.
  
  Currently, the implementation is restricted to using the logistic link
  function. For multi-class classification, several binary one-versus rest
  classifiers are fitted. Note that this class thus does not implement
  a true multi-class Laplace approximation.
  
  Parameters
  ----------
  kernel : kernel object
      The kernel specifying the covariance function of the GP. If None is
      passed, the kernel "1.0 * RBF(1.0)" is used as default. Note that
      the kernel's hyperparameters are optimized during fitting.
  
  optimizer : string or callable, optional (default: "fmin_l_bfgs_b")
      Can either be one of the internally supported optimizers for optimizing
      the kernel's parameters, specified by a string, or an externally
      defined optimizer passed as a callable. If a callable is passed, it
      must have the  signature::
  
          def optimizer(obj_func, initial_theta, bounds):
              # * 'obj_func' is the objective function to be maximized, which
              #   takes the hyperparameters theta as parameter and an
              #   optional flag eval_gradient, which determines if the
              #   gradient is returned additionally to the function value
              # * 'initial_theta': the initial value for theta, which can be
              #   used by local optimizers
              # * 'bounds': the bounds on the values of theta
              ....
              # Returned are the best found hyperparameters theta and
              # the corresponding value of the target function.
              return theta_opt, func_min
  
      Per default, the 'fmin_l_bfgs_b' algorithm from scipy.optimize
      is used. If None is passed, the kernel's parameters are kept fixed.
      Available internal optimizers are::
  
          'fmin_l_bfgs_b'
  
  n_restarts_optimizer : int, optional (default: 0)
      The number of restarts of the optimizer for finding the kernel's
      parameters which maximize the log-marginal likelihood. The first run
      of the optimizer is performed from the kernel's initial parameters,
      the remaining ones (if any) from thetas sampled log-uniform randomly
      from the space of allowed theta-values. If greater than 0, all bounds
      must be finite. Note that n_restarts_optimizer=0 implies that one
      run is performed.
  
  max_iter_predict : int, optional (default: 100)
      The maximum number of iterations in Newton's method for approximating
      the posterior during predict. Smaller values will reduce computation
      time at the cost of worse results.
  
  warm_start : bool, optional (default: False)
      If warm-starts are enabled, the solution of the last Newton iteration
      on the Laplace approximation of the posterior mode is used as
      initialization for the next call of _posterior_mode(). This can speed
      up convergence when _posterior_mode is called several times on similar
      problems as in hyperparameter optimization.
  
  copy_X_train : bool, optional (default: True)
      If True, a persistent copy of the training data is stored in the
      object. Otherwise, just a reference to the training data is stored,
      which might cause predictions to change if the data is modified
      externally.
  
  random_state : integer or numpy.RandomState, optional
      The generator used to initialize the centers. If an integer is
      given, it fixes the seed. Defaults to the global numpy random
      number generator.
  
  multi_class: string, default : "one_vs_rest"
      Specifies how multi-class classification problems are handled.
      Supported are "one_vs_rest" and "one_vs_one". In "one_vs_rest",
      one binary Gaussian process classifier is fitted for each class, which
      is trained to separate this class from the rest. In "one_vs_one", one
      binary Gaussian process classifier is fitted for each pair of classes,
      which is trained to separate these two classes. The predictions of
      these binary predictors are combined into multi-class predictions.
      Note that "one_vs_one" does not support predicting probability
      estimates.
  
  n_jobs : int, optional, default: 1
      The number of jobs to use for the computation. If -1 all CPUs are used.
      If 1 is given, no parallel computing code is used at all, which is
      useful for debugging. For n_jobs below -1, (n_cpus + 1 + n_jobs) are
      used. Thus for n_jobs = -2, all CPUs but one are used.
  
  Attributes
  ----------
  kernel_ : kernel object
      The kernel used for prediction. In case of binary classification,
      the structure of the kernel is the same as the one passed as parameter
      but with optimized hyperparameters. In case of multi-class
      classification, a CompoundKernel is returned which consists of the
      different kernels used in the one-versus-rest classifiers.
  
  log_marginal_likelihood_value_ : float
      The log-marginal-likelihood of ``self.kernel_.theta``
  
  classes_ : array-like, shape = (n_classes,)
      Unique class labels.
  
  n_classes_ : int
      The number of classes in the training data
  
  .. versionadded:: 0.18
docstr: Fit Gaussian process classification model
  
  Parameters
  ----------
  X : array-like, shape = (n_samples, n_features)
      Training data
  
  y : array-like, shape = (n_samples,)
      Target values, must be binary
  
  Returns
  -------
  self : returns an instance of self.
docstr_tok: ["Fit","Gaussian","process","classification","model","Parameters","--","--","--","--","--","X",":","array-like",",","shape","=","(","n_samples",",","n_features",")","Training","data","y",":","array-like",",","shape","=","(","n_samples",",",")","Target","values",",","must","be","binary","Returns","--","--","--","-","self",":","returns","an","instance","of","self","."]
code: def fit(self, X, y):
      """Fit Gaussian process classification model
  
      Parameters
      ----------
      X : array-like, shape = (n_samples, n_features)
          Training data
  
      y : array-like, shape = (n_samples,)
          Target values, must be binary
  
      Returns
      -------
      self : returns an instance of self.
      """
      X, y = check_X_y(X, y, multi_output=False)
  
      self.base_estimator_ = _BinaryGaussianProcessClassifierLaplace(
          self.kernel,
          self.optimizer,
          self.n_restarts_optimizer,
          self.max_iter_predict,
          self.warm_start,
          self.copy_X_train,
          self.random_state,
      )
  
      self.classes_ = np.unique(y)
      self.n_classes_ = self.classes_.size
      if self.n_classes_ == 1:
          raise ValueError(
              "GaussianProcessClassifier requires 2 or more "
              "distinct classes. Only class %s present."
              % self.classes_[0]
          )
      if self.n_classes_ > 2:
          if self.multi_class == "one_vs_rest":
              self.base_estimator_ = OneVsRestClassifier(
                  self.base_estimator_, n_jobs=self.n_jobs
              )
          elif self.multi_class == "one_vs_one":
              self.base_estimator_ = OneVsOneClassifier(
                  self.base_estimator_, n_jobs=self.n_jobs
              )
          else:
              raise ValueError(
                  "Unknown multi-class mode %s" % self.multi_class
              )
  
      self.base_estimator_.fit(X, y)
  
      if self.n_classes_ > 2:
          self.log_marginal_likelihood_value_ = np.mean(
              [
                  estimator.log_marginal_likelihood()
                  for estimator in self.base_estimator_.estimators_
              ]
          )
      else:
          self.log_marginal_likelihood_value_ = (
              self.base_estimator_.log_marginal_likelihood()
          )
  
      return self
  
imports: import warnings
  from operator import itemgetter
  import numpy
  from scipy.linalg import cholesky, cho_solve, solve
  from scipy.optimize import fmin_l_bfgs_b
  from scipy.special import erf
  from sklearn.base import BaseEstimator, ClassifierMixin, clone
  from sklearn.gaussian_process.kernels import RBF, CompoundKernel, ConstantKernel
  from sklearn.utils.validation import check_X_y, check_is_fitted, check_array
  from sklearn.utils import check_random_state
  from sklearn.preprocessing import LabelEncoder
  from sklearn.multiclass import OneVsRestClassifier, OneVsOneClassifier
label_desc: Use image node_id 2 for calling the GaussianProcessClassifier obj's underlying member method code with example usage: obj.fit(X, y) and returns: self