class_docstr: Auto Link Predictor.
  
  Used to automatically solve the link prediction problems.
  
  Parameters
  ----------
  feature_module: autogl.module.feature.BaseFeatureEngineer or str or None
      The (name of) auto feature engineer used to process the given dataset. Default ``deepgl``.
      Disable feature engineer by setting it to ``None``.
  
  graph_models: list of autogl.module.model.BaseModel or list of str
      The (name of) models to be optimized as backbone. Default ``['gat', 'gcn']``.
  
  hpo_module: autogl.module.hpo.BaseHPOptimizer or str or None
      The (name of) hpo module used to search for best hyper parameters. Default ``anneal``.
      Disable hpo by setting it to ``None``.
  
  ensemble_module: autogl.module.ensemble.BaseEnsembler or str or None
      The (name of) ensemble module used to ensemble the multi-models found. Default ``voting``.
      Disable ensemble by setting it to ``None``.
  
  max_evals: int (Optional)
      If given, will set the number eval times the hpo module will use.
      Only be effective when hpo_module is ``str``. Default ``None``.
  
  default_trainer: str (Optional)
      The (name of) the trainer used in this solver. Default to ``NodeClassificationFull``.
  
  trainer_hp_space: list of dict (Optional)
      trainer hp space or list of trainer hp spaces configuration.
      If a single trainer hp is given, will specify the hp space of trainer for every model.
      If a list of trainer hp is given, will specify every model with corrsponding
      trainer hp space.
      Default ``None``.
  
  model_hp_spaces: list of list of dict (Optional)
      model hp space configuration.
      If given, will specify every hp space of every passed model. Default ``None``.
      If the encoder(-decoder) is passed, the space should be a dict containing keys "encoder"
      and "decoder", specifying the detailed encoder decoder hp spaces.
  
  size: int (Optional)
      The max models ensemble module will use. Default ``None``.
  
  device: torch.device or str
      The device where model will be running on. If set to ``auto``, will use gpu when available.
      You can also specify the device by directly giving ``gpu`` or ``cuda:0``, etc.
      Default ``auto``.
code: def _predict_proba_by_name(self, dataset, name, mask="test"):
      self.trained_models[name].to(self.runtime_device)
      predicted = (
          self.trained_models[name]
          .predict_proba(self._compose_dataset(dataset), mask=mask)
          .cpu()
          .numpy()
      )
      self.trained_models[name].to(torch.device("cpu"))
      return predicted
  
imports: import logging
  import time
  import json
  from copy import deepcopy
  from typing import Sequence
  import torch
  import numpy
  import yaml
  from .base import BaseClassifier
  from ..base import _parse_hp_space, _initialize_single_model, _parse_model_hp
  from ...module.feature import FEATURE_DICT
  from ...module.train import TRAINER_DICT, BaseLinkPredictionTrainer
  from ...module.train import get_feval
  from ..utils import LeaderBoard, get_graph_node_features, convert_dataset, set_seed
  from ...datasets import utils
  from ..utils import get_logger
  from ...backend import DependentBackend
label_desc: Use image node_id 8 for calling the AutoLinkPredictor obj's underlying member method code with example usage: obj._predict_proba_by_name(dataset, name, mask) and returns: predicted