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
  >>> import dgl
  >>> from deepchem.models import AttentiveFP
  >>> smiles = ["C1CCC1", "C1=CC=CN=C1"]
  >>> featurizer = dc.feat.MolGraphConvFeaturizer(use_edges=True)
  >>> graphs = featurizer.featurize(smiles)
  >>> print(type(graphs[0]))
  <class 'deepchem.feat.graph_data.GraphData'>
  >>> dgl_graphs = [graphs[i].to_dgl_graph(self_loop=True) for i in range(len(graphs))]
  >>> # Batch two graphs into a graph of two connected components
  >>> batch_dgl_graph = dgl.batch(dgl_graphs)
  >>> model = AttentiveFP(n_tasks=1, mode='regression')
  >>> preds = model(batch_dgl_graph)
  >>> print(type(preds))
  <class 'torch.Tensor'>
  >>> preds.shape == (2, 1)
  True
  
  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.
  nfeat_name: str
      For an input graph ``g``, the model assumes that it stores node features in
      ``g.ndata[nfeat_name]`` and will retrieve input node features from that.
      Default to 'x'.
  efeat_name: str
      For an input graph ``g``, the model assumes that it stores edge features in
      ``g.edata[efeat_name]`` and will retrieve input edge features from that.
      Default to 'edge_attr'.
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,
      nfeat_name: str = "x",
      efeat_name: str = "edge_attr",
  ):
      """
      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.
      nfeat_name: str
          For an input graph ``g``, the model assumes that it stores node features in
          ``g.ndata[nfeat_name]`` and will retrieve input node features from that.
          Default to 'x'.
      efeat_name: str
          For an input graph ``g``, the model assumes that it stores edge features in
          ``g.edata[efeat_name]`` and will retrieve input edge features from that.
          Default to 'edge_attr'.
      """
      try:
          import dgl  # noqa: F401
      except:
          raise ImportError("This class requires dgl.")
      try:
          import dgllife  # noqa: F401
      except:
          raise ImportError("This class requires dgllife.")
  
      if mode not in ["classification", "regression"]:
          raise ValueError(
              "mode must be either 'classification' or 'regression'"
          )
  
      super(AttentiveFP, self).__init__()
  
      self.n_tasks = n_tasks
      self.mode = mode
      self.n_classes = n_classes
      self.nfeat_name = nfeat_name
      self.efeat_name = efeat_name
      if mode == "classification":
          out_size = n_tasks * n_classes
      else:
          out_size = n_tasks
  
      from dgllife.model import (
          AttentiveFPPredictor as DGLAttentiveFPPredictor,
      )
  
      self.model = DGLAttentiveFPPredictor(
          node_feat_size=number_atom_features,
          edge_feat_size=number_bond_features,
          num_layers=num_layers,
          num_timesteps=num_timesteps,
          graph_feat_size=graph_feat_size,
          n_tasks=out_size,
          dropout=dropout,
      )
  
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 AttentiveFP object from inherited base classes: nn with example: obj = AttentiveFP(n_tasks, num_layers, num_timesteps, graph_feat_size, dropout, mode, number_atom_features, number_bond_features, n_classes, nfeat_name, efeat_name)