class_docstr: Symbolic Fourier Approximation (SFA) Transformer.
  
  Overview: for each series:
      run a sliding window across the series
      for each window
          shorten the series with DFT
          discretise the shortened series into bins set by MFC
          form a word from these discrete values
  by default SFA produces a single word per series (window_size=0)
  if a window is used, it forms a histogram of counts of words.
  
  Parameters
  ----------
  word_length:         int, default = 8
      length of word to shorten window to (using PAA)
  
  alphabet_size:       int, default = 4
      number of values to discretise each value to
  
  window_size:         int, default = 12
      size of window for sliding. Input series
      length for whole series transform
  
  norm:                boolean, default = False
      mean normalise words by dropping first fourier coefficient
  
  binning_method:      {"equi-depth", "equi-width", "information-gain", "kmeans"},
                          default="equi-depth"
      the binning method used to derive the breakpoints.
  
  anova:               boolean, default = False
      If True, the Fourier coefficient selection is done via a one-way
      ANOVA test. If False, the first Fourier coefficients are selected.
      Only applicable if labels are given
  
  bigrams:             boolean, default = False
      whether to create bigrams of SFA words
  
  skip_grams:          boolean, default = False
      whether to create skip-grams of SFA words
  
  remove_repeat_words: boolean, default = False
      whether to use numerosity reduction (default False)
  
  levels:              int, default = 1
      Number of spatial pyramid levels
  
  save_words:          boolean, default = False
      whether to save the words generated for each series (default False)
  
  return_pandas_data_series:          boolean, default = False
      set to true to return Pandas Series as a result of transform.
      setting to true reduces speed significantly but is required for
      automatic test.
  
  n_jobs:              int, optional, default = 1
      The number of jobs to run in parallel for both `transform`.
      ``-1`` means using all processors.
  
  Attributes
  ----------
  words: []
  breakpoints: = []
  num_insts = 0
  num_atts = 0
  
  References
  ----------
  .. [1] Schäfer, Patrick, and Mikael Högqvist. "SFA: a symbolic fourier approximation
  and  index for similarity search in high dimensional datasets." Proceedings of the
  15th international conference on extending database technology. 2012.
code: def _transform_case(self, X, supplied_dft=None):
      from numba import types
      from numba.typed import Dict
  
      from sktime.transformations.panel.dictionary_based._sfa_numba import (
          _create_word,
      )
  
      if supplied_dft is None:
          dfts = self._mft(X)
      else:
          dfts = supplied_dft
  
      if self.typed_dict:
          bag = (
              Dict.empty(
                  key_type=types.UniTuple(types.int64, 2),
                  value_type=types.uint32,
              )
              if self.levels > 1
              else Dict.empty(
                  key_type=types.int64, value_type=types.uint32
              )
          )
      else:
          bag = {}
  
      last_word = -1
      repeat_words = 0
      words = (
          np.zeros(dfts.shape[0], dtype=np.int64)
          if self.word_bits <= 64
          else [0 for _ in range(dfts.shape[0])]
      )
  
      for window in range(dfts.shape[0]):
          word_raw = (
              _create_word(
                  dfts[window],
                  self.word_length,
                  self.alphabet_size,
                  self.breakpoints,
                  self.letter_bits,
              )
              if self.word_bits <= 64
              else self._create_word_large(
                  dfts[window],
              )
          )
          words[window] = word_raw
  
          repeat_word = (
              self._add_to_pyramid(
                  bag,
                  word_raw,
                  last_word,
                  window - int(repeat_words / 2),
              )
              if self.levels > 1
              else self._add_to_bag(bag, word_raw, last_word)
          )
  
          if repeat_word:
              repeat_words += 1
          else:
              last_word = word_raw
              repeat_words = 0
  
          if self.bigrams:
              if window - self.window_size >= 0:
                  bigram = self._create_bigram_words(
                      word_raw, words[window - self.window_size]
                  )
  
                  if self.levels > 1:
                      if self.typed_dict:
                          bigram = (bigram, -1)
                      else:
                          bigram = (bigram << self.level_bits) | 0
                  bag[bigram] = bag.get(bigram, 0) + 1
  
          if self.skip_grams:
              # creates skip-grams, skipping every (s-1)-th word in-between
              for s in range(2, 4):
                  if window - s * self.window_size >= 0:
                      skip_gram = self._create_bigram_words(
                          word_raw, words[window - s * self.window_size]
                      )
  
                      if self.levels > 1:
                          if self.typed_dict:
                              skip_gram = (skip_gram, -1)
                          else:
                              skip_gram = (
                                  skip_gram << self.level_bits
                              ) | 0
                      bag[skip_gram] = bag.get(skip_gram, 0) + 1
  
      # can't pickle typed dict
      if self.typed_dict and self.n_jobs != 1:
          pdict = dict()
          for key, val in bag.items():
              pdict[key] = val
          bag = pdict
  
      return [
          pd.Series(bag) if self.return_pandas_data_series else bag,
          words if self.save_words else [],
      ]
  
imports: import math
  import sys
  import warnings
  import numpy
  import pandas
  from joblib import Parallel, delayed
  from sklearn.feature_selection import f_classif
  from sklearn.preprocessing import KBinsDiscretizer
  from sklearn.tree import DecisionTreeClassifier
  from sktime.transformations.base import BaseTransformer
  from sktime.utils.validation.panel import check_X
label_desc: Use image node_id 4 for calling the SFA obj's underlying member method code with example usage: obj._transform_case(X, supplied_dft) and returns: list