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.
docstr: Calculate word breakpoints using MCB or IGB.
  
  Parameters
  ----------
  X : pandas DataFrame or 3d numpy array, input time series.
  y : array_like, target values (optional, ignored).
  
  Returns
  -------
  self: object
docstr_tok: ["Calculate","word","breakpoints","using","MCB","or","IGB",".","Parameters","--","--","--","--","--","X",":","pandas","DataFrame","or","3d","numpy","array",",","input","time","series",".","y",":","array_like",",","target","values","(","optional",",","ignored",")",".","Returns","--","--","--","-","self",":","object"]
code: def fit(self, X, y=None):
      """Calculate word breakpoints using MCB or IGB.
  
      Parameters
      ----------
      X : pandas DataFrame or 3d numpy array, input time series.
      y : array_like, target values (optional, ignored).
  
      Returns
      -------
      self: object
      """
      if self.alphabet_size < 2:
          raise ValueError(
              "Alphabet size must be an integer greater than 2"
          )
  
      if self.word_length < 1:
          raise ValueError(
              "Word length must be an integer greater than 1"
          )
  
      if self.binning_method == "information-gain" and y is None:
          raise ValueError(
              "Class values must be provided for information gain binning"
          )
  
      if self.binning_method not in binning_methods:
          raise TypeError(
              "binning_method must be one of: ", binning_methods
          )
  
      self.letter_bits = math.ceil(math.log2(self.alphabet_size))
      self.letter_max = pow(2, self.letter_bits) - 1
      self.word_bits = self.word_length * self.letter_bits
      self.max_bits = (
          self.word_bits * 2
          if self.bigrams or self.skip_grams
          else self.word_bits
      )
  
      if self.typed_dict and self.max_bits > 64:
          raise ValueError(
              "Typed Dictionaries can only handle 64 bit words. "
              "ceil(log2(alphabet_size)) * word_length must be less than or equal "
              "to 64."
              "With bi-grams or skip-grams enabled, this bit limit is 32."
          )
  
      if self.typed_dict and self.levels > 15:
          raise ValueError(
              "Typed Dictionaries can only handle 15 levels "
              "(this is way to many anyway)."
          )
  
      X = check_X(X, enforce_univariate=True, coerce_to_numpy=True)
      X = X.squeeze(1)
  
      if self.levels > 1:
          quadrants = 0
          for i in range(self.levels):
              quadrants += pow(2, i)
          self.level_bits = math.ceil(math.log2(quadrants))
          self.level_max = pow(2, self.level_bits) - 1
  
      self.n_instances, self.series_length = X.shape
      self.breakpoints = self._binning(X, y)
  
      self._is_fitted = True
      return self
  
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 2 for calling the SFA obj's underlying member method code with example usage: obj.fit(X, y) and returns: self