code: def predict_global(
      self, ind, last_step=100, future=10, normalize=False, bsize=90
  ):
      if ind is None:
          ind = np.arange(self.Ymat.shape[0])
  
      self.Xseq = self.Xseq.eval()
  
      rg = max(
          1
          + 2
          * (self.kernel_size - 1)
          * 2 ** (len(self.num_channels_X) - 1),
          1
          + 2
          * (self.kernel_size_Y - 1)
          * 2 ** (len(self.num_channels_Y) - 1),
      )
      X = self.X[:, last_step - rg : last_step]
      n = X.size(0)
      T = X.size(1)
      X = self.tensor2d_to_temporal(X)
      outX = self.predict_future(
          model=self.Xseq, inp=X, future=future, bsize=bsize
      )
  
      outX = self.temporal_to_tensor2d(outX)
  
      F = self.F
  
      Y = torch.matmul(F, outX)
  
      Y = np.array(Y[ind, :].detach())
  
      del F
  
      for p in self.Xseq.parameters():
          p.requires_grad = True
  
      if normalize:
          Y = Y - self.mini
          Y = Y * self.s[ind, None] + self.m[ind, None]
          return Y
      else:
          return Y
  
imports: from __future__ import print_function
  import torch
  import numpy
  import pandas
  import torch.nn
  import torch.optim
  from torch.autograd import Variable
  from zoo.chronos.model.tcmf.data_loader import TCMFDataLoader
  from zoo.chronos.model.tcmf.local_model import TemporalConvNet, LocalModel
  from zoo.chronos.model.tcmf.time import TimeCovariates
  import copy
  import pickle
  import logging
label_desc: Use image node_id 11 for calling the DeepGLO obj's underlying member method code with example usage: obj.predict_global(ind, last_step, future, normalize, bsize) and returns: Y, Y