code: def asynchronous_compute_gradient(self, batch_ctx, encryptor, w, X):
      h = X.shape[0]
      Xw_h = torch.matmul(X, w.detach())
      batch_ctx.guest.put(
          "Xw_h", encryptor.encrypt_tensor(Xw_h, obfuscate=True)
      )
      half_g = torch.matmul(X.T, Xw_h)
      guest_half_d = batch_ctx.guest.get("half_d")
      if self.floating_point_precision:
          guest_half_g = torch.matmul(
              torch.encode_as_int_f(X.T, self.floating_point_precision),
              guest_half_d,
          )
          guest_half_g = 1 / self._fixpoint_precision * guest_half_g
      else:
          guest_half_g = torch.matmul(X.T, guest_half_d)
  
      batch_ctx.guest.put(
          "Xw2_h", encryptor.encrypt_tensor(torch.matmul(Xw_h.T, Xw_h))
      )
      loss_norm = self.optimizer.loss_norm(w)
      if loss_norm is not None:
          batch_ctx.guest.put(
              "h_loss", encryptor.encrypt_tensor(loss_norm)
          )
      else:
          batch_ctx.guest.put(h_loss=loss_norm)
  
      g = 1 / h * (half_g + guest_half_g)
      return g
  
imports: import logging
  import torch
  from fate.arch import Context
  from fate.arch.dataframe import DataLoader
  from fate.ml.abc.module import HeteroModule
  from fate.ml.utils._model_param import deserialize_param, initialize_param, serialize_param
  from fate.ml.utils._optimizer import LRScheduler, Optimizer
label_desc: Use image node_id 2 for calling the CoordinatedLinREstimatorHost obj's underlying member method code with example usage: obj.asynchronous_compute_gradient(batch_ctx, encryptor, w, X) and returns: g