docs: def diy(expression_data,
          regressor_type,
          regressor_kwargs,
          gene_names=None,
          tf_names='all',
          client_or_address='local',
          early_stop_window_length=EARLY_STOP_WINDOW_LENGTH,
          limit=None,
          seed=None,
          verbose=False):
      """
      :param expression_data: one of:
             * a pandas DataFrame (rows=observations, columns=genes)
             * a dense 2D numpy.ndarray
             * a sparse scipy.sparse.csc_matrix
      :param regressor_type: string. One of: 'RF', 'GBM', 'ET'. Case insensitive.
      :param regressor_kwargs: a dictionary of key-value pairs that configures the regressor.
      :param gene_names: optional list of gene names (strings). Required when a (dense or sparse) matrix is passed as
                         'expression_data' instead of a DataFrame.
      :param tf_names: optional list of transcription factors. If None or 'all', the list of gene_names will be used.
      :param early_stop_window_length: early stopping window length.
      :param client_or_address: one of:
             * None or 'local': a new Client(LocalCluster()) will be used to perform the computation.
             * string address: a new Client(address) will be used to perform the computation.
             * a Client instance: the specified Client instance will be used to perform the computation.
      :param limit: optional number (int) of top regulatory links to return. Default None.
      :param seed: optional random seed for the regressors. Default 666. Use None for random seed.
      :param verbose: print info.
      :return: a pandas DataFrame['TF', 'target', 'importance'] representing the inferred gene regulatory links.
      """
      if verbose:
          print('preparing dask client')
  
      client, shutdown_callback = _prepare_client(client_or_address)
  
      try:
          if verbose:
              print('parsing input')
  
          expression_matrix, gene_names, tf_names = _prepare_input(expression_data, gene_names, tf_names)
  
          if verbose:
              print('creating dask graph')
  
          graph = create_graph(expression_matrix,
                               gene_names,
                               tf_names,
                               client=client,
                               regressor_type=regressor_type,
                               regressor_kwargs=regressor_kwargs,
                               early_stop_window_length=early_stop_window_length,
                               limit=limit,
                               seed=seed)
  
          if verbose:
              print('{} partitions'.format(graph.npartitions))
              print('computing dask graph')
  
          return client \
              .compute(graph, sync=True) \
              .sort_values(by='importance', ascending=False)
  
      finally:
          shutdown_callback(verbose)
  
          if verbose:
              print('finished')