code: def test_fit():
      # Test that the algorithm solution is equal to a worked out example.
      X = np.array([[0.6, 0.8, 0.7]])
      y = np.array([0])
      mlp = MLPClassifier(
          solver="sgd",
          learning_rate_init=0.1,
          alpha=0.1,
          activation="logistic",
          random_state=1,
          max_iter=1,
          hidden_layer_sizes=2,
          momentum=0,
      )
      # set weights
      mlp.coefs_ = [0] * 2
      mlp.intercepts_ = [0] * 2
      mlp.n_outputs_ = 1
      mlp.coefs_[0] = np.array([[0.1, 0.2], [0.3, 0.1], [0.5, 0]])
      mlp.coefs_[1] = np.array([[0.1], [0.2]])
      mlp.intercepts_[0] = np.array([0.1, 0.1])
      mlp.intercepts_[1] = np.array([1.0])
      mlp._coef_grads = [] * 2
      mlp._intercept_grads = [] * 2
      mlp.n_features_in_ = 3
  
      # Initialize parameters
      mlp.n_iter_ = 0
      mlp.learning_rate_ = 0.1
  
      # Compute the number of layers
      mlp.n_layers_ = 3
  
      # Pre-allocate gradient matrices
      mlp._coef_grads = [0] * (mlp.n_layers_ - 1)
      mlp._intercept_grads = [0] * (mlp.n_layers_ - 1)
  
      mlp.out_activation_ = "logistic"
      mlp.t_ = 0
      mlp.best_loss_ = np.inf
      mlp.loss_curve_ = []
      mlp._no_improvement_count = 0
      mlp._intercept_velocity = [
          np.zeros_like(intercepts) for intercepts in mlp.intercepts_
      ]
      mlp._coef_velocity = [
          np.zeros_like(coefs) for coefs in mlp.coefs_
      ]
  
      mlp.partial_fit(X, y, classes=[0, 1])
      # Manually worked out example
      # h1 = g(X1 * W_i1 + b11) = g(0.6 * 0.1 + 0.8 * 0.3 + 0.7 * 0.5 + 0.1)
      #       =  0.679178699175393
      # h2 = g(X2 * W_i2 + b12) = g(0.6 * 0.2 + 0.8 * 0.1 + 0.7 * 0 + 0.1)
      #         = 0.574442516811659
      # o1 = g(h * W2 + b21) = g(0.679 * 0.1 + 0.574 * 0.2 + 1)
      #       = 0.7654329236196236
      # d21 = -(0 - 0.765) = 0.765
      # d11 = (1 - 0.679) * 0.679 * 0.765 * 0.1 = 0.01667
      # d12 = (1 - 0.574) * 0.574 * 0.765 * 0.2 = 0.0374
      # W1grad11 = X1 * d11 + alpha * W11 = 0.6 * 0.01667 + 0.1 * 0.1 = 0.0200
      # W1grad11 = X1 * d12 + alpha * W12 = 0.6 * 0.0374 + 0.1 * 0.2 = 0.04244
      # W1grad21 = X2 * d11 + alpha * W13 = 0.8 * 0.01667 + 0.1 * 0.3 = 0.043336
      # W1grad22 = X2 * d12 + alpha * W14 = 0.8 * 0.0374 + 0.1 * 0.1 = 0.03992
      # W1grad31 = X3 * d11 + alpha * W15 = 0.6 * 0.01667 + 0.1 * 0.5 = 0.060002
      # W1grad32 = X3 * d12 + alpha * W16 = 0.6 * 0.0374 + 0.1 * 0 = 0.02244
      # W2grad1 = h1 * d21 + alpha * W21 = 0.679 * 0.765 + 0.1 * 0.1 = 0.5294
      # W2grad2 = h2 * d21 + alpha * W22 = 0.574 * 0.765 + 0.1 * 0.2 = 0.45911
      # b1grad1 = d11 = 0.01667
      # b1grad2 = d12 = 0.0374
      # b2grad = d21 = 0.765
      # W1 = W1 - eta * [W1grad11, .., W1grad32] = [[0.1, 0.2], [0.3, 0.1],
      #          [0.5, 0]] - 0.1 * [[0.0200, 0.04244], [0.043336, 0.03992],
      #          [0.060002, 0.02244]] = [[0.098, 0.195756], [0.2956664,
      #          0.096008], [0.4939998, -0.002244]]
      # W2 = W2 - eta * [W2grad1, W2grad2] = [[0.1], [0.2]] - 0.1 *
      #        [[0.5294], [0.45911]] = [[0.04706], [0.154089]]
      # b1 = b1 - eta * [b1grad1, b1grad2] = 0.1 - 0.1 * [0.01667, 0.0374]
      #         = [0.098333, 0.09626]
      # b2 = b2 - eta * b2grad = 1.0 - 0.1 * 0.765 = 0.9235
      assert_almost_equal(
          mlp.coefs_[0],
          np.array(
              [
                  [0.098, 0.195756],
                  [0.2956664, 0.096008],
                  [0.4939998, -0.002244],
              ]
          ),
          decimal=3,
      )
      assert_almost_equal(
          mlp.coefs_[1], np.array([[0.04706], [0.154089]]), decimal=3
      )
      assert_almost_equal(
          mlp.intercepts_[0], np.array([0.098333, 0.09626]), decimal=3
      )
      assert_almost_equal(
          mlp.intercepts_[1], np.array(0.9235), decimal=3
      )
      # Testing output
      #  h1 = g(X1 * W_i1 + b11) = g(0.6 * 0.098 + 0.8 * 0.2956664 +
      #               0.7 * 0.4939998 + 0.098333) = 0.677
      #  h2 = g(X2 * W_i2 + b12) = g(0.6 * 0.195756 + 0.8 * 0.096008 +
      #            0.7 * -0.002244 + 0.09626) = 0.572
      #  o1 = h * W2 + b21 = 0.677 * 0.04706 +
      #             0.572 * 0.154089 + 0.9235 = 1.043
      #  prob = sigmoid(o1) = 0.739
      assert_almost_equal(mlp.predict_proba(X)[0, 1], 0.739, decimal=3)
  
imports: import re
  import sys
  import warnings
  from io import StringIO
  import joblib
  import numpy
  import pytest
  from numpy.testing import assert_allclose, assert_almost_equal, assert_array_equal
  from sklearn.datasets import load_digits, load_iris, make_multilabel_classification, make_regression
  from sklearn.exceptions import ConvergenceWarning
  from sklearn.metrics import roc_auc_score
  from sklearn.neural_network import MLPClassifier, MLPRegressor
  from sklearn.preprocessing import LabelBinarizer, MinMaxScaler, scale
  from sklearn.utils._testing import ignore_warnings
  from sklearn.utils.fixes import CSR_CONTAINERS
label_desc: Use image node_id 2 for calling a global function with example usage: test_fit() without return types