class_docstr: Model for Graph Property Prediction.
  
  This model proceeds as follows:
  
  * Combine node features and edge features for initializing node representations,
      which involves a round of message passing
  * Update node representations with multiple rounds of message passing
  * For each graph, compute its representation by combining the representations
      of all nodes in it, which involves a gated recurrent unit (GRU).
  * Perform the final prediction using a linear layer
  
  Examples
  --------
  >>> import deepchem as dc
  >>> from deepchem.models import AttentiveFPModel
  >>> # preparing dataset
  >>> smiles = ["C1CCC1", "C1=CC=CN=C1"]
  >>> labels = [0., 1.]
  >>> featurizer = dc.feat.MolGraphConvFeaturizer(use_edges=True)
  >>> X = featurizer.featurize(smiles)
  >>> dataset = dc.data.NumpyDataset(X=X, y=labels)
  >>> # training model
  >>> model = AttentiveFPModel(mode='classification', n_tasks=1,
  ...    batch_size=16, learning_rate=0.001)
  >>> loss = model.fit(dataset, nb_epoch=5)
  
  References
  ----------
  .. [1] Zhaoping Xiong, Dingyan Wang, Xiaohong Liu, Feisheng Zhong, Xiaozhe Wan, Xutong Li,
      Zhaojun Li, Xiaomin Luo, Kaixian Chen, Hualiang Jiang, and Mingyue Zheng. "Pushing
      the Boundaries of Molecular Representation for Drug Discovery with the Graph
      Attention Mechanism." Journal of Medicinal Chemistry. 2020, 63, 16, 8749–8760.
  
  Notes
  -----
  This class requires DGL (https://github.com/dmlc/dgl) and DGL-LifeSci
  (https://github.com/awslabs/dgl-lifesci) to be installed.
docstr: Parameters
  ----------
  n_tasks: int
      Number of tasks.
  num_layers: int
      Number of graph neural network layers, i.e. number of rounds of message passing.
      Default to 2.
  num_timesteps: int
      Number of time steps for updating graph representations with a GRU. Default to 2.
  graph_feat_size: int
      Size for graph representations. Default to 200.
  dropout: float
      Dropout probability. Default to 0.
  mode: str
      The model type, 'classification' or 'regression'. Default to 'regression'.
  number_atom_features: int
      The length of the initial atom feature vectors. Default to 30.
  number_bond_features: int
      The length of the initial bond feature vectors. Default to 11.
  n_classes: int
      The number of classes to predict per task
      (only used when ``mode`` is 'classification'). Default to 2.
  self_loop: bool
      Whether to add self loops for the nodes, i.e. edges from nodes to themselves.
      When input graphs have isolated nodes, self loops allow preserving the original feature
      of them in message passing. Default to True.
  kwargs
      This can include any keyword argument of TorchModel.
code: def __init__(
      self,
      n_tasks: int,
      num_layers: int = 2,
      num_timesteps: int = 2,
      graph_feat_size: int = 200,
      dropout: float = 0.0,
      mode: str = "regression",
      number_atom_features: int = 30,
      number_bond_features: int = 11,
      n_classes: int = 2,
      self_loop: bool = True,
      **kwargs,
  ):
      """
      Parameters
      ----------
      n_tasks: int
          Number of tasks.
      num_layers: int
          Number of graph neural network layers, i.e. number of rounds of message passing.
          Default to 2.
      num_timesteps: int
          Number of time steps for updating graph representations with a GRU. Default to 2.
      graph_feat_size: int
          Size for graph representations. Default to 200.
      dropout: float
          Dropout probability. Default to 0.
      mode: str
          The model type, 'classification' or 'regression'. Default to 'regression'.
      number_atom_features: int
          The length of the initial atom feature vectors. Default to 30.
      number_bond_features: int
          The length of the initial bond feature vectors. Default to 11.
      n_classes: int
          The number of classes to predict per task
          (only used when ``mode`` is 'classification'). Default to 2.
      self_loop: bool
          Whether to add self loops for the nodes, i.e. edges from nodes to themselves.
          When input graphs have isolated nodes, self loops allow preserving the original feature
          of them in message passing. Default to True.
      kwargs
          This can include any keyword argument of TorchModel.
      """
      model = AttentiveFP(
          n_tasks=n_tasks,
          num_layers=num_layers,
          num_timesteps=num_timesteps,
          graph_feat_size=graph_feat_size,
          dropout=dropout,
          mode=mode,
          number_atom_features=number_atom_features,
          number_bond_features=number_bond_features,
          n_classes=n_classes,
      )
      if mode == "regression":
          loss: Loss = L2Loss()
          output_types = ["prediction"]
      else:
          loss = SparseSoftmaxCrossEntropy()
          output_types = ["prediction", "loss"]
      super(AttentiveFPModel, self).__init__(
          model, loss=loss, output_types=output_types, **kwargs
      )
  
      self._self_loop = self_loop
  
file_path: deepchem/deepchem/models/torch_models/attentivefp.py
imports: import torch.nn
  import torch.nn.functional
  from deepchem.models.losses import Loss, L2Loss, SparseSoftmaxCrossEntropy
  from deepchem.models.torch_models.torch_model import TorchModel
label_desc: Use image node_id 1 to create a new AttentiveFPModel object from inherited base classes: TorchModel with example: obj = AttentiveFPModel(n_tasks, num_layers, num_timesteps, graph_feat_size, dropout, mode, number_atom_features, number_bond_features, n_classes, _loop)