docstr: We leave the weights initialization here. 
docstr_tok: ["We","leave","the","weights","initialization","here","."]
code: def _init_weight_(self):
      """We leave the weights initialization here."""
      if not self.model == "NeuMF-pre":
          nn.init.normal_(self.embed_user_GMF.weight, std=0.01)
          nn.init.normal_(self.embed_user_MLP.weight, std=0.01)
          nn.init.normal_(self.embed_item_GMF.weight, std=0.01)
          nn.init.normal_(self.embed_item_MLP.weight, std=0.01)
          for embed_MLP in self.embed_catFeats_MLP:
              nn.init.normal_(embed_MLP.weight, std=0.01)
  
          for m in self.MLP_layers:
              if isinstance(m, nn.Linear):
                  nn.init.xavier_uniform_(m.weight)
          nn.init.kaiming_uniform_(
              self.predict_layer.weight, a=1, nonlinearity="sigmoid"
          )
  
          for m in self.modules():
              if isinstance(m, nn.Linear) and m.bias is not None:
                  m.bias.data.zero_()
      else:
          # embedding layers
          self.embed_user_GMF.weight.data.copy_(
              self.GMF_model.embed_user_GMF.weight
          )
          self.embed_item_GMF.weight.data.copy_(
              self.GMF_model.embed_item_GMF.weight
          )
          self.embed_user_MLP.weight.data.copy_(
              self.MLP_model.embed_user_MLP.weight
          )
          self.embed_item_MLP.weight.data.copy_(
              self.MLP_model.embed_item_MLP.weight
          )
          for i in range(len(self.embed_catFeats_MLP)):
              self.embed_catFeats_MLP[i].weight.data.copy_(
                  self.MLP_model.embed_catFeats_MLP[i].weight
              )
  
          # mlp layers
          for m1, m2 in zip(self.MLP_layers, self.MLP_model.MLP_layers):
              if isinstance(m1, nn.Linear) and isinstance(
                  m2, nn.Linear
              ):
                  m1.weight.data.copy_(m2.weight)
                  m1.bias.data.copy_(m2.bias)
  
          # predict layers
          predict_weight = torch.cat(
              [
                  self.GMF_model.predict_layer.weight,
                  self.MLP_model.predict_layer.weight,
              ],
              dim=1,
          )
          precit_bias = (
              self.GMF_model.predict_layer.bias
              + self.MLP_model.predict_layer.bias
          )
  
          self.predict_layer.weight.data.copy_(0.5 * predict_weight)
          self.predict_layer.bias.data.copy_(0.5 * precit_bias)
  
imports: import torch
  import torch.nn
label_desc: Use image node_id 2 for calling the NCF obj's underlying member method code with example usage: obj._init_weight_() without return types