def __init__(
        self,
        estimator: "CLASSIFIER_TYPE" | "REGRESSOR_TYPE",
        input_type: str = "prediction",
        attack_model_type: str = "nn",
        attack_model: Any | None = None,
        scaler_type: str | None = "standard",
        nn_model_epochs: int = 100,
        nn_model_batch_size: int = 100,
        nn_model_learning_rate: float = 0.0001,
    ):
        """
        Create a MembershipInferenceBlackBox attack instance.

        :param estimator: Target estimator.
        :param input_type: the type of input to train the attack on. Can be one of: 'prediction' or 'loss'. Default is
                           `prediction`. Predictions can be either probabilities or logits, depending on the return type
                           of the model. If the model is a regressor, only `loss` can be used.
        :param attack_model_type: the type of default attack model to train, optional. Should be one of:
                                 `nn` (neural network, default),
                                 `rf` (random forest),
                                 `gb` (gradient boosting),
                                 `lr` (logistic regression),
                                 `dt` (decision tree),
                                 `knn` (k nearest neighbors),
                                 `svm` (support vector machine).
                                 If `attack_model` is supplied, this option will be ignored.
        :param attack_model: The attack model to train, optional. If none is provided, a default model will be created.
        :param scaler_type: The type of scaling to apply to the input features to the attack. Can be one of: "standard",
                            "minmax", "robust" or None. If not None, the appropriate scaler from scikit-learn will be
                            applied. If None, no scaling will be applied.
        :param nn_model_epochs: the number of epochs to use when training a nn attack model
        :param nn_model_batch_size: the batch size to use when training a nn attack model
        :param nn_model_learning_rate: the learning rate to use when training a nn attack model
        """

        super().__init__(estimator=estimator)
        self.input_type = input_type
        self.attack_model_type = attack_model_type
        self.attack_model = attack_model
        self.scaler_type = scaler_type
        self.scaler: Any | None = None
        self.epochs = nn_model_epochs
        self.batch_size = nn_model_batch_size
        self.learning_rate = nn_model_learning_rate
        self.use_label = True

        self._regressor_model = RegressorMixin in type(self.estimator).__mro__

        self._check_params()

        if self.attack_model:
            self.default_model = False
            self.attack_model_type = "None"
        else:
            self.default_model = True

            if self.attack_model_type == "rf":
                self.attack_model = RandomForestClassifier()
            elif self.attack_model_type == "gb":
                self.attack_model = GradientBoostingClassifier()
            elif self.attack_model_type == "lr":
                self.attack_model = LogisticRegression()
            elif self.attack_model_type == "dt":
                self.attack_model = DecisionTreeClassifier()
            elif self.attack_model_type == "knn":
                self.attack_model = KNeighborsClassifier()
            elif self.attack_model_type == "svm":
                self.attack_model = SVC(probability=True)
            elif attack_model_type != "nn":
                raise ValueError("Illegal value for parameter `attack_model_type`.")

        Create a MembershipInferenceBlackBox attack instance.

        :param estimator: Target estimator.
        :param input_type: the type of input to train the attack on. Can be one of: 'prediction' or 'loss'. Default is
                           `prediction`. Predictions can be either probabilities or logits, depending on the return type
                           of the model. If the model is a regressor, only `loss` can be used.
        :param attack_model_type: the type of default attack model to train, optional. Should be one of:
                                 `nn` (neural network, default),
                                 `rf` (random forest),
                                 `gb` (gradient boosting),
                                 `lr` (logistic regression),
                                 `dt` (decision tree),
                                 `knn` (k nearest neighbors),
                                 `svm` (support vector machine).
                                 If `attack_model` is supplied, this option will be ignored.
        :param attack_model: The attack model to train, optional. If none is provided, a default model will be created.
        :param scaler_type: The type of scaling to apply to the input features to the attack. Can be one of: "standard",
                            "minmax", "robust" or None. If not None, the appropriate scaler from scikit-learn will be
                            applied. If None, no scaling will be applied.
        :param nn_model_epochs: the number of epochs to use when training a nn attack model
        :param nn_model_batch_size: the batch size to use when training a nn attack model
        :param nn_model_learning_rate: the learning rate to use when training a nn attack model
        
art/attacks/inference/membership_inference/black_box.py