Summary  
This chapter demonstrates how to configure, train, and use a neural network model with scikit-learn’s MLPClassifier by setting hyperparameters like hidden_layer_sizes, max_iter, and learning_rate_init, then calling fit() and predict().

General domain of usage  
Classification tasks in machine learning

Working with neural networks can be quite tricky, especially if you're trying to build them **from scratch**. Instead of manually coding algorithms and formulas, you can use **ready-made tools** such as the `sklearn` library.

## Benefits of Using sklearn

1. **Ease of use:** you don't have to dive deep into the details of each algorithm. You can simply use ready-made methods and classes;

2. **Optimization:** the `sklearn` library is optimized for performance, which can reduce the training time of your model;

3. **Extensive documentation:** `sklearn` provides extensive documentation with usage examples, which can greatly speed up the learning process;

4. **Compatibility:** `sklearn` integrates well with other popular Python libraries such as `numpy`, `pandas` and `matplotlib`.

## Perceptron in sklearn

To create the same model as in this section, you can use the `MLPClassifier` class from the `sklearn` library. Its key parameters are as follows:

- `max_iter`: defines the maximum number of epochs for training;  
- `hidden_layer_sizes`: specifies the number of neurons in each hidden layer as a tuple;  
- `learning_rate_init`: sets the learning rate for weight updates.

By default, `MLPClassifier` uses the **ReLU** activation function for **hidden** layers. For binary classification, the **output** layer is essentially the same as the one you implemented.

Note

For example, with a single line of code, you can create a perceptron with **two hidden layers** of `10` neurons each, using at most `100` epochs for training and a learning rate of `0.5`:

```python
from sklearn.neural_network import MLPClassifier

model = MLPClassifier(max_iter=100, hidden_layer_sizes=(10,10), learning_rate_init=0.5)
```

Neural networks in `sklearn` determine the **number of inputs and outputs** based on the data they are trained on. Therefore, there is no need to set them manually.

As with our implementation, **training the model** simply involves calling the `fit()` method:

```python
model.fit(X_train, y_train)
```

To get the **predicted labels** (e.g., on the test set), all you have to do is call the `predict()` method:

```python
y_pred = model.predict(X_test)
```

import unittest
import importlib
import numpy as np


def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)


class TestSklearnPerceptron(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.user_code = importlib.import_module("user_code")

        from sklearn.model_selection import train_test_split
        from sklearn.neural_network import MLPClassifier
        from sklearn.metrics import accuracy_score
        from perceptron import X, y

        cls.MLPClassifier = MLPClassifier
        cls.accuracy_score = accuracy_score
        cls.X = X
        cls.y = y
        cls.X_train, cls.X_test, cls.y_train, cls.y_test = train_test_split(
            cls.X, cls.y, test_size=0.2, random_state=10
        )

    def test_model_initialization(self):
        model = getattr(self.user_code, "model", None)
        _dynamic_test(
            self,
            model is not None,
            "Model variable defined",
            "Model variable not found in user code",
        )
        if model is not None:
            correct_type = model.__class__.__name__ == "MLPClassifier"
            correct_layers = getattr(model, "hidden_layer_sizes", None) == (6, 6)
            correct_iter = getattr(model, "max_iter", None) == 100
            correct_lr = np.isclose(getattr(model, "learning_rate_init", None), 0.01)
            _dynamic_test(
                self,
                correct_type and correct_layers and correct_iter and correct_lr,
                "Model initialized correctly with sklearn MLPClassifier",
                f"Model parameters incorrect: hidden={getattr(model, 'hidden_layer_sizes', None)}, "
                f"max_iter={getattr(model, 'max_iter', None)}, lr={getattr(model, 'learning_rate_init', None)}",
            )

    def test_model_training(self):
        model = self.user_code.model
        model.fit(self.X_train, self.y_train)
        trained = hasattr(model, "coefs_") and all(isinstance(w, np.ndarray) for w in model.coefs_)
        _dynamic_test(
            self,
            trained,
            "Model trained successfully using fit()",
            "Model not trained correctly (weights not found)",
        )

    def test_predictions_shape(self):
        y_pred = getattr(self.user_code, "y_pred", None)
        _dynamic_test(
            self,
            y_pred is not None and isinstance(y_pred, np.ndarray),
            "Predictions stored in a NumPy array",
            "Predictions missing or incorrect type",
        )
        if y_pred is not None:
            # Accept (n,) or (n,1); compare after squeeze
            pred_flat = np.squeeze(y_pred)
            ytest_flat = np.squeeze(self.y_test)
            same_len = pred_flat.shape == ytest_flat.shape
            _dynamic_test(
                self,
                same_len,
                "Predictions have correct shape",
                f"Predictions shape incorrect: got {y_pred.shape}, expected {self.y_test.shape} or {ytest_flat.shape}",
            )

    def test_accuracy_computation(self):
        score = getattr(self.user_code, "score", None)
        _dynamic_test(
            self,
            score is not None and isinstance(score, (float, np.floating)),
            "Accuracy score variable defined and numeric",
            "Accuracy score missing or incorrect type",
        )
        if score is not None:
            _dynamic_test(
                self,
                0.5 <= score <= 1.0,
                "Accuracy value within realistic range (0.5–1.0)",
                f"Accuracy value unrealistic: {score}",
            )


if __name__ == "__main__":
    unittest.main(argv=["first-arg-is-ignored"], exit=False)


test_code.py

Neural networks are powerful algorithms inspired by the structure of the human brain that are used to solve complex machine learning problems. You will build your own Neural Network from scratch to understand how it works. After this course, you will be able to create neural networks for solving classification and regression problems using the scikit-learn library.

First, we will discuss what a neural network is and how it works. And also consider the scope of its application.

Next, we will try to build our own neural network and see how efficiently it copes with learning. We will also consider a ready-made solution from the scikit-learn library.

Finally, we will give you some additional useful information on how to understand which model to use and what types of neural networks there are. To complete the course, you will be tested on your acquired knowledge.

Neural Network with scikit-learn

Benefits of Using sklearn

Perceptron in sklearn

解答