code: def make_sparse_data(use_feature_hashing=False):
      """
      Create sparse data for use in various tests.
  
      Function to create sparse data with two features always zero
      in the training set and a different one always zero in the
      test set.
  
      Parameters
      ----------
      use_feature_hashing : bool, optional
          Whether to use feature hashing.
          Defaults to ``False``.
  
      Returns
      -------
      Tuple
          Tuple containing the generated training featureset and
          the generated test featureset.
      """
      # Create training data
      X, y = make_classification(
          n_samples=500,
          n_features=3,
          n_informative=3,
          n_redundant=0,
          n_classes=2,
          random_state=1234567890,
      )
  
      # we need features to be non-negative since we will be
      # using naive bayes laster
      X = np.abs(X)
  
      # make sure that none of the features are zero
      X[np.where(X == 0)] += 1
  
      # since we want to use SKLL's FeatureSet class, we need to
      # create a list of IDs
      ids = [f"EXAMPLE_{n}" for n in range(1, 501)]
  
      # create a list of dictionaries as the features
      # with f1 and f5 always 0
      feature_names = [f"f{n}" for n in range(1, 6)]
      features = []
      for row in X:
          row = [0] + row.tolist() + [0]
          features.append(dict(zip(feature_names, row)))
  
      # use a FeatureHasher if we are asked to do feature hashing
      vectorizer = (
          FeatureHasher(n_features=4) if use_feature_hashing else None
      )
      train_fs = FeatureSet(
          "train_sparse",
          ids,
          features=features,
          labels=y,
          vectorizer=vectorizer,
      )
  
      # now create the test set with f4 always 0 but nothing else
      X, y = make_classification(
          n_samples=100,
          n_features=4,
          n_informative=4,
          n_redundant=0,
          n_classes=2,
          random_state=1234567890,
      )
      X = np.abs(X)
      X[np.where(X == 0)] += 1
      ids = [f"EXAMPLE_{n}" for n in range(1, 101)]
  
      # create a list of dictionaries as the features
      # with f4 always 0
      feature_names = [f"f{n}" for n in range(1, 6)]
      features = []
      for row in X:
          row = row.tolist()
          row = row[:3] + [0] + row[3:]
          features.append(dict(zip(feature_names, row)))
  
      test_fs = FeatureSet(
          "test_sparse",
          ids,
          features=features,
          labels=y,
          vectorizer=vectorizer,
      )
  
      return train_fs, test_fs
  
imports: import os
  import re
  from collections import OrderedDict
  from math import floor, log10
  from pathlib import Path
  from typing import Any, Dict, List, Optional, Tuple
  import numpy
  from numpy.random import RandomState
  from sklearn.datasets import fetch_california_housing, load_digits, make_classification, make_regression
  from sklearn.feature_extraction import FeatureHasher
  from sklearn.model_selection import KFold, ShuffleSplit, StratifiedKFold
  from sklearn.utils import shuffle
  from skll.config import _setup_config_parser, fix_json
  from skll.data import FeatureSet, NDJWriter
  from skll.types import PathOrStr
label_desc: Use image node_id 11 for calling a global function with example usage: make_sparse_data(use_feature_hashing) and returns: train_fs,  test_fs