继承具有“最大递归深度超出”错误的LabelBinarizer类

Question

I created a customized encoder class from LabelBinarizer. Here's what it looks like

class my_lb(LabelBinarizer):

  def fit(self, X, y=None):
    self.fit(X)

  def transform(self, X, y=None):
    return self.transform(X)

  def fit_transform(self, X, y=None):
    return self.fit(X).transform(X)

And I have the "maximum recursion depth exceeded" error, which occurred at the fit method. I was able to make it right following some notes online:

class my_lb(LabelBinarizer):

  def __init__(self):
    super().__init__()

  def fit(self, X, y=None):
    super().fit(X)

  def transform(self, X, y=None):
    return super().transform(X)

  def fit_transform(self, X, y=None):
    return super().fit(X).transform(X)

But my question is, how does it solve my problem? I can understand the cause in other posts here (which I can see are constructing an explicit infinite loop), but I read the codes of LabelBinarizer, and it looks pretty normal to me. I can't find anything that may cause an infinite loop.

def fit(self, y): 
        self.y_type_ = type_of_target(y)
        if 'multioutput' in self.y_type_:
             raise ValueError("Multioutput target data is not supported with "
                              "label binarization")
        if _num_samples(y) == 0:
            raise ValueError('y has 0 samples: %r' % y)
        self.sparse_input_ = sp.issparse(y)
        self.classes_ = unique_labels(y)
        return self

Can anyone tell me what am I missing here? It will also help me know better when super is needed when I create an inheriting class.

Answer 1

Before it was changed to call super() , calling any one of the methods shown would have caused infinite recursion. fit and transform are obvious, they just called themselves so if they were ever called, they would never return and you would exceed the maximum recursion depth.

fit_transform , on the other hand, was calling self.fit(X).transform(X) . So the first thing it did was call self.fit(X) , which just called itself over and over until the error occurred.

The modified versions, on the other hand, pass the calls along to the parent class versions of fit and transform , via the call to super() , so they don't call themselves. In fact, with those calls in place, you don't even need to call super() from fit_transform .

But the best fix is to simply delete the definitions of fit and transform in the derived class, and remove the call to super() from fit_transform , which isn't needed.