code: def __init__(self, config, dataset):
      super(FEARec, self).__init__(config, dataset)
  
      # load parameters info
      self.dataset = dataset
      self.config = config
      self.n_layers = config["n_layers"]
      self.n_heads = config["n_heads"]
      self.hidden_size = config["hidden_size"]  # same as embedding_size
      self.inner_size = config[
          "inner_size"
      ]  # the dimensionality in feed-forward layer
      self.hidden_dropout_prob = config["hidden_dropout_prob"]
      self.attn_dropout_prob = config["attn_dropout_prob"]
      self.hidden_act = config["hidden_act"]
      self.layer_norm_eps = config["layer_norm_eps"]
  
      self.lmd = config["lmd"]
      self.lmd_sem = config["lmd_sem"]
  
      self.initializer_range = config["initializer_range"]
      self.loss_type = config["loss_type"]
      self.same_item_index = self.get_same_item_index(dataset)
  
      # define layers and loss
      self.item_embedding = nn.Embedding(
          self.n_items, self.hidden_size, padding_idx=0
      )
      self.position_embedding = nn.Embedding(
          self.max_seq_length, self.hidden_size
      )
      self.item_encoder = FEAEncoder(
          n_layers=self.n_layers,
          n_heads=self.n_heads,
          hidden_size=self.hidden_size,
          inner_size=self.inner_size,
          hidden_dropout_prob=self.hidden_dropout_prob,
          attn_dropout_prob=self.attn_dropout_prob,
          hidden_act=self.hidden_act,
          layer_norm_eps=self.layer_norm_eps,
          config=self.config,
      )
  
      self.LayerNorm = nn.LayerNorm(
          self.hidden_size, eps=self.layer_norm_eps
      )
      self.dropout = nn.Dropout(self.hidden_dropout_prob)
  
      if self.loss_type == "BPR":
          self.loss_fct = BPRLoss()
      elif self.loss_type == "CE":
          self.loss_fct = nn.CrossEntropyLoss()
      else:
          raise NotImplementedError(
              "Make sure 'loss_type' in ['BPR', 'CE']!"
          )
  
      self.ssl = config["contrast"]
      self.tau = config["tau"]
      self.sim = config["sim"]
      self.fredom = config["fredom"]
      self.fredom_type = config["fredom_type"]
      self.batch_size = config["train_batch_size"]
      self.mask_default = self.mask_correlated_samples(
          batch_size=self.batch_size
      )
      self.aug_nce_fct = nn.CrossEntropyLoss()
      self.sem_aug_nce_fct = nn.CrossEntropyLoss()
  
      # parameters initialization
      self.apply(self._init_weights)
  
imports: import random
  import numpy
  import torch
  from torch import nn
  import torch.nn.functional
  import math
  import torch.nn.functional
  from recbole.model.abstract_recommender import SequentialRecommender
  from recbole.model.loss import BPRLoss
  from recbole.data.interaction import Interaction
label_desc: Use image node_id 1 to create a new FEARec object from inherited base classes: SequentialRecommender with example: obj = FEARec(config, dataset)