为什么在神经网络中需要非线性激活函数?

import torchimport numpy as npfrom lets_plot import *import pandas as pd

from sklearn.datasets import make_moonsX, y = make_moons(n_samples=10000, noise=0.2, random_state=10)df = pd.DataFrame(X, columns=['feature1', 'feature2'])df['y'] = yggplot(df, aes('feature1', 'feature2', color='y')) + geom_point(size=0.7) + scale_color_discrete() + labs(title="Toy dataset")

class DemoModel(torch.nn.Module):    def __init__(self, use_relu=False):        super().__init__()        self.use_relu = use_relu        self.fc1 = torch.nn.Linear(2, 10)        self.fc2 = torch.nn.Linear(10, 2)
    def forward(self, x):        x = self.fc1(x)        if self.use_relu:            x = torch.relu(x)        return self.fc2(x)
linear_model = DemoModel(use_relu=False)non_linear_model = DemoModel(use_relu=True)

from sklearn.model_selection import train_test_splitfrom torch.utils.data import TensorDataset, DataLoader
def train(model: torch.nn.Module, train_dl, val_dl, epochs=10, ):    optim = torch.optim.AdamW(model.parameters(), lr=1e-3)    loss_fn = torch.nn.CrossEntropyLoss()    losses = []    for epoch in range(epochs):        train_loss = 0.0        model.train()        for batch_X, batch_y in train_dl:            optim.zero_grad()            logits = model(batch_X)            loss = loss_fn(logits, batch_y)            loss.backward()            optim.step()            train_loss += loss.item() * batch_X.size(0)
        train_loss /= len(train_dl.dataset)
        model.eval()        val_loss = 0.0        with torch.no_grad():            for batch_X, batch_y in val_dl:                logits = model(batch_X)                loss = loss_fn(logits, batch_y)                val_loss += loss.item() * batch_X.size(0)
        val_loss /= len(val_dl.dataset)        log_steps = int(0.2 * epochs)
        losses.append((train_loss, val_loss))        if epoch % log_steps == 0 or epoch == epochs - 1:            print(f'Epoch {epoch+1}/{epochs}, Training Loss: {train_loss:.4f}, Validation Loss: {val_loss:.4f}')
    return losses

X_train, X_test, y_train, y_test = train_test_split(torch.Tensor(X), torch.LongTensor(y))train_ds = TensorDataset(X_train, y_train)test_ds = TensorDataset(X_test, y_test)train_dl = DataLoader(train_ds, shuffle=True, batch_size=32)test_dl = DataLoader(test_ds, shuffle=False, batch_size=32)

linear_losses = train(linear_model, train_dl, test_dl, epochs=50)non_linear_losses = train(non_linear_model, train_dl, test_dl, epochs=50)

from sklearn.metrics import classification_reportfrom lets_plot.mapping import as_discrete
def plot_classification(model, model_name: str):    preds = model(X_test).argmax(dim=1).numpy()    report_dict = (classification_report(y_test, preds, output_dict=True))    plot_df = pd.DataFrame({"feature1": X_test[:, 0].numpy(), "feature2": X_test[: ,1].numpy(), "y": y_test, "pred": preds})    title = f"{model_name}"    subtitle = f"Accuracy: {report_dict['accuracy']:.2}, F1-Score {report_dict['weighted avg']['f1-score']:.2}"    return ggplot(plot_df) + geom_point(aes('feature1', 'feature2', color=as_discrete('pred'), shape=as_discrete('y')), size=2.5, alpha=0.7) + labs(title=title, subtitle=subtitle, color="Predicted Class", shape="Actual Class")
fig_linear = plot_classification(linear_model, model_name="Linear")fig_non_linear = plot_classification(non_linear_model, model_name="Non Linear")bunch = GGBunch()bunch.add_plot(fig_linear, 0, 0)bunch.add_plot(fig_non_linear, 600, 0)bunch

def plot_activations(activations, labels, title: str):    df_logits = pd.DataFrame(        activations, columns=[f"Neuron_{i+1}" for i in range(activations.shape[1])]    )    df_logits['Label'] = labels    df_logits["Sample"] = range(1, len(df_logits) + 1)

    df_logits = df_logits.melt(        id_vars="Sample", var_name="Neuron"    )    return (        ggplot(df_logits, aes("Neuron", as_discrete("Sample")))        + geom_tile(aes(fill="value"))        + geom_text(aes(label="value"), label_format=".1", color='black')        + scale_fill_brewer(type='seq', palette=9)        + labs(title=title)            )
with torch.no_grad():    logits_fc1 = non_linear_model.fc1(X_test[:10])    logits_fc1_relu = torch.relu(logits_fc1)    logits_fc2 = non_linear_model.fc2(logits_fc1_relu)
bunch = GGBunch()bunch.add_plot(    plot_activations(logits_fc1.numpy(), y_test[:10], title="Output of fc1 of Non-Linear Model"), 0, 0, 500, 500)bunch.add_plot(    plot_activations(logits_fc1_relu.numpy(), y_test[:10], title="Output of fc1 of Non-Linear Model after RELU"), 502, -7, 500, 510)bunch.add_plot(    plot_activations(logits_fc2.numpy(), y_test[:10], title="Output of fc2"), 872, 9, 500, 478)
display(bunch)
bunch = GGBunch()with torch.no_grad():    linear_logits_fc1 = linear_model.fc1(X_test[:10])    linear_logits_fc2 = linear_model.fc2(logits_fc1_relu)
bunch.add_plot(    plot_activations(linear_logits_fc1.numpy(), y_test[:10], title="Output of fc1 of Linear Model"), 0, 0, 500, 500)bunch.add_plot(    plot_activations(linear_logits_fc2.numpy(), y_test[:10], title="Output of fc2"), 375, 15, 500, 470)bunch