需要在learning_curve函数里里得到train_loss，score参数如何设置

在 `learning_curve` 函数中，`train_loss` 和 `score` 参数都需要传入一个函数对象，分别用于计算训练损失和评估模型性能。

对于 `train_loss` 参数，你可以传入一个函数来计算每一轮训练后的损失，该函数应该接受一个训练集的迭代器和模型对象，然后返回当前训练轮次的平均损失。

对于 `score` 参数，通常情况下，你可以传入一个函数来评估模型的性能，该函数应该接受一个测试集的迭代器和模型对象，然后返回一个评估指标，例如准确率、F1 值等等。

具体的实现，可以参考以下示例代码：

import torch
from sklearn.metrics import accuracy_score

def train_loss(data_loader, model):
    model.train()
    loss_fn = torch.nn.CrossEntropyLoss()
    total_loss = 0.0
    n = 0

    for batch in data_loader:
        inputs, targets = batch
        outputs = model(inputs)
        loss = loss_fn(outputs, targets)
        total_loss += loss.item() * len(inputs)
        n += len(inputs)

    return total_loss / n

def test_score(data_loader, model):
    model.eval()
    y_true, y_pred = [], []

    with torch.no_grad():
        for batch in data_loader:
            inputs, targets = batch
            outputs = model(inputs)
            _, preds = torch.max(outputs, dim=1)
            y_true.extend(targets.tolist())
            y_pred.extend(preds.tolist())

    return accuracy_score(y_true, y_pred)

# 使用示例
from torch.utils.data import DataLoader, TensorDataset
import numpy as np

X_train = np.random.random(size=(1000, 10))
y_train = np.random.randint(0, 2, size=(1000,))
train_dataset = TensorDataset(torch.tensor(X_train), torch.tensor(y_train))
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

X_test = np.random.random(size=(200, 10))
y_test = np.random.randint(0, 2, size=(200,))
test_dataset = TensorDataset(torch.tensor(X_test), torch.tensor(y_test))
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

from skorch import NeuralNetClassifier
from skorch.callbacks import EarlyStopping

net = NeuralNetClassifier(
    module=torch.nn.Linear(10, 2),
    criterion=torch.nn.CrossEntropyLoss,
    optimizer=torch.optim.SGD,
    max_epochs=100,
    callbacks=[EarlyStopping(patience=5)],
)

from skorch.utils import to_device
from functools import partial

to_device(net, 'cuda')

partial_train_loss = partial(train_loss, model=net.module_)
partial_test_score = partial(test_score, model=net.module_)

from skorch.utils import to_numpy
train_loss_values, test_score_values = learning_curve(
    net, train_loader, train_sizes=np.linspace(0.1, 1.0, 5),
    scoring=partial_test_score, scoring_train=partial_train_loss,
    device='cuda', verbose=1, n_jobs=1
)

print('Train loss:', train_loss_values)
print('Test score:', test_score_values)

在这个例子中，我们定义了两个函数 `train_loss` 和 `test_score`。其中，`train_loss` 用于计算每一轮训练后的平均损失，`test_score` 用于评估模型在测试集上的准确率。我们通过 `partial` 函数将这两个函数转化为只需要传入数据集和模型对象的函数对象，并将它们作为 `scoring_train` 和 `scoring` 参数传给 `learning_curve` 函数。在 `learning_curve` 函数中，我们使用 `train_sizes` 参数来控制不同大小的训练集上的训练和评估，并使用 `n_jobs` 参数来并行计算。

最终，`learning_curve` 函数将返回训练集大小和对应的训练损失以及测试集大小和对应的评估指标，你可以将它们用于可视化学习曲线。