class_docstr: DIEN has an interest extractor layer to capture temporal interests from history behavior sequence,and an
  interest evolving layer to capture interest evolving process that is relative to the target item. At interest
  evolving layer, attention mechanism is embedded intothe sequential structure novelly, and the effects of relative
  interests are strengthened during interest evolution.
code: def __init__(self, config, dataset):
      super(DIEN, self).__init__(config, dataset)
  
      # get field names and parameter value from config
      self.device = config["device"]
      self.alpha = config["alpha"]
      self.gru = config["gru_type"]
      self.pooling_mode = config["pooling_mode"]
      self.dropout_prob = config["dropout_prob"]
      self.LABEL_FIELD = config["LABEL_FIELD"]
      self.embedding_size = config["embedding_size"]
      self.mlp_hidden_size = config["mlp_hidden_size"]
      self.NEG_ITEM_SEQ = config["NEG_PREFIX"] + self.ITEM_SEQ
  
      self.types = ["user", "item"]
      self.user_feat = dataset.get_user_feature()
      self.item_feat = dataset.get_item_feature()
  
      num_item_feature = sum(
          1
          if dataset.field2type[field]
          not in [FeatureType.FLOAT_SEQ, FeatureType.FLOAT]
          or field in config["numerical_features"]
          else 0
          for field in self.item_feat.interaction.keys()
      )
      num_user_feature = sum(
          1
          if dataset.field2type[field]
          not in [FeatureType.FLOAT_SEQ, FeatureType.FLOAT]
          or field in config["numerical_features"]
          else 0
          for field in self.user_feat.interaction.keys()
      )
      item_feat_dim = num_item_feature * self.embedding_size
      mask_mat = (
          torch.arange(self.max_seq_length).to(self.device).view(1, -1)
      )  # init mask
  
      # init sizes of used layers
      self.att_list = [
          4 * num_item_feature * self.embedding_size
      ] + self.mlp_hidden_size
      self.interest_mlp_list = (
          [2 * item_feat_dim] + self.mlp_hidden_size + [1]
      )
      self.dnn_mlp_list = [
          2 * item_feat_dim + num_user_feature * self.embedding_size
      ] + self.mlp_hidden_size
  
      # init interest extractor layer, interest evolving layer embedding layer, MLP layer and linear layer
      self.interset_extractor = InterestExtractorNetwork(
          item_feat_dim, item_feat_dim, self.interest_mlp_list
      )
      self.interest_evolution = InterestEvolvingLayer(
          mask_mat,
          item_feat_dim,
          item_feat_dim,
          self.att_list,
          gru=self.gru,
      )
      self.embedding_layer = ContextSeqEmbLayer(
          dataset, self.embedding_size, self.pooling_mode, self.device
      )
      self.dnn_mlp_layers = MLPLayers(
          self.dnn_mlp_list,
          activation="Dice",
          dropout=self.dropout_prob,
          bn=True,
      )
      self.dnn_predict_layer = nn.Linear(self.mlp_hidden_size[-1], 1)
      self.sigmoid = nn.Sigmoid()
      self.loss = nn.BCEWithLogitsLoss()
  
      self.apply(self._init_weights)
      self.other_parameter_name = ["embedding_layer"]
  
imports: import torch
  import torch.nn
  import torch.nn.functional
  from torch.nn.init import xavier_normal_, constant_
  from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence, PackedSequence
  from recbole.utils import ModelType, InputType, FeatureType
  from recbole.model.layers import FMEmbedding, MLPLayers, ContextSeqEmbLayer, SequenceAttLayer
  from recbole.model.abstract_recommender import SequentialRecommender
label_desc: Use image node_id 1 to create a new DIEN object from inherited base classes: SequentialRecommender with example: obj = DIEN(config, dataset)