code: def get_oof_matrix(self, models):
      # remember models, will be needed in predictions
      self.models_map = {m.get_name(): m for m in models}
  
      if self._max_single_prediction_time is not None:
          self.model_prediction_time = {
              m.get_name(): m._single_prediction_time for m in models
          }
  
          if not [
              m
              for m in models
              if m.is_fast_enough(self._max_single_prediction_time)
          ]:
              raise NotTrainedException(
                  "Can't contruct ensemble with prediction time smaller than limit."
              )
  
      # check if we can construct fair ensemble
      if self._fairness_metric is not None:
          if not [m for m in models if m.is_fair()]:
              raise NotTrainedException("Can't contruct fair ensemble.")
  
      oofs = {}
      sensitive_features = None
      for m in models:
          # do not use model with RandomFeature
          if "RandomFeature" in m.get_name():
              continue
  
          # ensemble only the same level of stack
          # if m._is_stacked != self._is_stacked:
          #    continue
          oof = m.get_out_of_folds()
          prediction_cols = [
              c for c in oof.columns if "prediction" in c
          ]
          oofs[m.get_name()] = oof[prediction_cols]  # oof["prediction"]
          if self.target is None:
              self.target_columns = [
                  c for c in oof.columns if "target" in c
              ]
              self.target = oof[
                  self.target_columns
              ]  # it will be needed for computing advance model statistics
  
          if (
              self.sample_weight is None
              and "sample_weight" in oof.columns
          ):
              self.sample_weight = oof["sample_weight"]
  
          sensitive_cols = [c for c in oof.columns if "sensitive" in c]
          if sensitive_cols and sensitive_features is None:
              sensitive_features = oof[sensitive_cols]
  
      return oofs, self.target, self.sample_weight, sensitive_features
  
imports: import copy
  import json
  import logging
  import operator
  import os
  import time
  import uuid
  import numpy
  import pandas
  from supervised.algorithms.algorithm import BaseAlgorithm
  from supervised.algorithms.registry import BINARY_CLASSIFICATION, MULTICLASS_CLASSIFICATION, REGRESSION
  from supervised.exceptions import NotTrainedException
  from supervised.model_framework import ModelFramework
  from supervised.utils.additional_metrics import AdditionalMetrics
  from supervised.utils.config import LOG_LEVEL
  from supervised.utils.metric import Metric
  from supervised.utils.jsonencoder import MLJSONEncoder
  import matplotlib.pyplot
  from tabulate import tabulate
  from supervised.utils.learning_curves import LearningCurves
label_desc: Use image node_id 13 for calling the Ensemble obj's underlying member method code with example usage: obj.get_oof_matrix(models) and returns: oofs,  self,  self,  sensitive_features