code: def _benchmark(trial):
      from sklearn.ensemble import RandomForestClassifier
      from sklearn.svm import LinearSVC
      from sklearn.calibration import CalibratedClassifierCV
      from sklearn.model_selection import train_test_split
      from sklearn.metrics import roc_auc_score
      from sklearn.pipeline import Pipeline
      from sklearn.preprocessing import (
          OneHotEncoder,
          FunctionTransformer,
      )
      from sklearn.compose import ColumnTransformer
      from sklearn.impute import SimpleImputer
  
      if (
          trial.task.problem == "binary"
          and trial.task.origin == "openml"
      ):
          X, y, meta = trial.task.data(["X", "y", "meta"])
  
          # Holdout split
          X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3)
  
          # Build preprocessor
          is_cat = meta["categorical_mask"]
          cat_cols = [idx for idx in range(X.shape[1]) if is_cat[idx]]
          num_cols = [
              idx for idx in range(X.shape[1]) if not is_cat[idx]
          ]
          cat_ohe_step = (
              "ohe",
              OneHotEncoder(sparse=True, handle_unknown="ignore"),
          )
          cat_pipe = Pipeline([cat_ohe_step])
          num_pipe = Pipeline([("identity", FunctionTransformer())])
          transformers = [
              ("cat", cat_pipe, cat_cols),
              ("num", num_pipe, num_cols),
          ]
          ct = Pipeline(
              [
                  ("ct", ColumnTransformer(transformers=transformers)),
                  (
                      "missing",
                      SimpleImputer(
                          add_indicator=True, strategy="most_frequent"
                      ),
                  ),
              ]
          )
          # Connect preprocessor with target learner
          if trial.method.name == "svm":
              clf = Pipeline(
                  [
                      ("ct", ct),
                      ("est", CalibratedClassifierCV(LinearSVC())),
                  ]
              )
          else:
              clf = Pipeline(
                  [("ct", ct), ("est", RandomForestClassifier())]
              )
  
          # Train
          clf.fit(X_tr, y_tr)
  
          # Predict
          predictions = clf.predict_proba(X_te)[:, 1]
  
          # Score
          auc = roc_auc_score(y_te, predictions)
          trial.log("auc", auc)
  
file_path: interpret/python/powerlift/tests/powerlift/bench/test_experiment.py
imports: from powerlift.bench import Experiment, Store
  from powerlift.executors.docker import InsecureDocker
  from powerlift.executors.localmachine import LocalMachine
  from powerlift.executors.azure_ci import AzureContainerInstance
  import pytest
  import os
label_desc: Use image node_id 4 for calling a global function with example usage: _benchmark(trial) without return types