class_docstr: Linear model (scikit-learn): https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html
  
  Model backend differs depending on problem_type:
  
      'binary' & 'multiclass': https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html
  
      'regression': https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html#sklearn.linear_model.Ridge
code: def _preprocess_train(self, X, feature_types, vect_max_features):
      transformer_list = []
      if feature_types.get("language", None):
          pipeline = Pipeline(
              steps=[
                  (
                      "preparator",
                      NlpDataPreprocessor(
                          nlp_cols=feature_types["language"]
                      ),
                  ),
                  (
                      "vectorizer",
                      TfidfVectorizer(
                          ngram_range=self.params["proc.ngram_range"],
                          sublinear_tf=True,
                          max_features=vect_max_features,
                          tokenizer=self._tokenize,
                      ),
                  ),
              ]
          )
          transformer_list.append(
              ("vect", pipeline, feature_types["language"])
          )
      if feature_types.get("onehot", None):
          pipeline = Pipeline(
              steps=[
                  ("generator", OheFeaturesGenerator()),
              ]
          )
          transformer_list.append(
              ("cats", pipeline, feature_types["onehot"])
          )
      if feature_types.get("continuous", None):
          pipeline = Pipeline(
              steps=[
                  (
                      "imputer",
                      SimpleImputer(
                          strategy=self.params["proc.impute_strategy"]
                      ),
                  ),
                  ("scaler", StandardScaler()),
              ]
          )
          transformer_list.append(
              ("cont", pipeline, feature_types["continuous"])
          )
      if feature_types.get("bool", None):
          pipeline = Pipeline(steps=[("scaler", StandardScaler())])
          transformer_list.append(
              ("bool", pipeline, feature_types["bool"])
          )
      if feature_types.get("skewed", None):
          pipeline = Pipeline(
              steps=[
                  (
                      "imputer",
                      SimpleImputer(
                          strategy=self.params["proc.impute_strategy"]
                      ),
                  ),
                  (
                      "quantile",
                      QuantileTransformer(output_distribution="normal"),
                  ),  # Or output_distribution = 'uniform'
              ]
          )
          transformer_list.append(
              ("skew", pipeline, feature_types["skewed"])
          )
      self._pipeline = ColumnTransformer(transformers=transformer_list)
      return self._pipeline.fit_transform(X)
  
imports: import logging
  import re
  import time
  import warnings
  from collections import defaultdict
  import numpy
  from sklearn.compose import ColumnTransformer
  from sklearn.feature_extraction.text import TfidfVectorizer
  from sklearn.impute import SimpleImputer
  from sklearn.pipeline import Pipeline
  from sklearn.preprocessing import QuantileTransformer, StandardScaler
  from autogluon.common.features.types import R_BOOL, R_CATEGORY, R_FLOAT, R_INT, R_OBJECT, S_BOOL, S_TEXT_AS_CATEGORY
  from autogluon.core.constants import BINARY, REGRESSION
  from autogluon.core.models import AbstractModel
  from autogluon.core.utils.exceptions import TimeLimitExceeded
  from .hyperparameters.parameters import IGNORE, INCLUDE, ONLY, _get_solver, get_param_baseline, preprocess_params_set
  from .hyperparameters.searchspaces import get_default_searchspace
  from .lr_preprocessing_utils import NlpDataPreprocessor, OheFeaturesGenerator
label_desc: Use image node_id 7 for calling the LinearModel obj's underlying member method code with example usage: obj._preprocess_train(X, feature_types, vect_max_features) and returns: self