华电软工非全研究生-玩深度学习之加速调参的方法

    import torch
    import torch.nn as nn
    import torch.optim as optim
    from torch.autograd import Variable
    from sklearn.model_selection import train_test_split
    from sklearn.datasets import load_iris
    
    # EarlyStopping 类定义
    class EarlyStopping:
    def __init__(self, patience=2, verbose=False):
        self.patience = patience
        self.verbose = verbose
        self.counter = 0
        self.best_score = None
        self.early_stop = False
        self.val_loss_min = float('inf')
    
    def __call__(self, val_loss, model):
        score = -val_loss
    
        if self.best_score is None:
            self.best_score = score
        elif score < self.best_score:
            self.counter += 1
            if self.verbose:
                print(f'EarlyStopping counter: {self.counter} out of {self.patience}')
            if self.counter >= self.patience:
                self.early_stop = True
        else:
            self.best_score = score
            self.counter = 0
    
    # 加载数据
    iris = load_iris()
    X = iris.data
    y = iris.target
    X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
    X_train = torch.from_numpy(X_train).float()
    y_train = torch.from_numpy(y_train).long()
    X_val = torch.from_numpy(X_val).float()
    y_val = torch.from_numpy(y_val).long()
    
    # 创建模型
    model = nn.Sequential(nn.Linear(4, 16),
                      nn.ReLU(),
                      nn.Linear(16, 3))
    
    # 设定损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.01)
    
    # 初始化 EarlyStopping 对象
    early_stopping = EarlyStopping(patience=3, verbose=True)
    
    for epoch in range(100):  
    # 前向传播
    y_pred = model(X_train)
    # 计算损失
    loss = criterion(y_pred, y_train)
    # 反向传播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    # 在验证集上计算损失
    with torch.no_grad():
        y_val_pred = model(X_val)
        val_loss = criterion(y_val_pred, y_val)
    
    print(f'Epoch {epoch}, Train Loss: {loss.item()}, Validation Loss: {val_loss.item()}')
    
    # 检查是否需要早停
    early_stopping(val_loss.item(), model)
    
    if early_stopping.early_stop:
        print("Early stopping")
        break
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    import torch
    from torch.autograd import Variable
    from torch.optim import SGD
    from skopt import BayesSearchCV
    from sklearn.model_selection import StratifiedKFold
    from sklearn.base import BaseEstimator, ClassifierMixin
    from sklearn.exceptions import NotFittedError
    
    class TorchClassifier(BaseEstimator, ClassifierMixin):
    def __init__(self, hidden_layer_size=20, dropout=0.5, epochs=10, lr=0.01):
        self.hidden_layer_size = hidden_layer_size
        self.dropout = dropout
        self.epochs = epochs
        self.lr = lr
        self.fitted_ = False
    
    def fit(self, X, y):
        self.model_ = torch.nn.Sequential(
            torch.nn.Linear(X.shape[1], self.hidden_layer_size),
            torch.nn.ReLU(),
            torch.nn.Dropout(self.dropout),
            torch.nn.Linear(self.hidden_layer_size, len(set(y)))
        )
    
        loss_fn = torch.nn.CrossEntropyLoss()
        optimizer = SGD(self.model_.parameters(), lr=self.lr)
    
        for _ in range(self.epochs):
            inputs = Variable(torch.from_numpy(X.astype(np.float32)))
            targets = Variable(torch.from_numpy(y.astype(np.int)))
    
            optimizer.zero_grad()
            outputs = self.model_(inputs)
            loss = loss_fn(outputs, targets)
            loss.backward()
            optimizer.step()
    
        self.fitted_ = True
        return self
    
    def predict(self, X):
        if not self.fitted_:
            raise NotFittedError()
    
        inputs = Variable(torch.from_numpy(X.astype(np.float32)))
        outputs = self.model_(inputs)
        _, preds = torch.max(outputs.data, 1)
        return preds.numpy()
    
    # 然后我们可以用 `BayesSearchCV` 来寻找最优的 dropout 参数：
    search_space = {"dropout": (0.1, 0.5)}
    cv = StratifiedKFold(n_splits=3)  # 假设你的数据是平衡的
    
    torch_model = TorchClassifier(epochs=10)
    bayes_search = BayesSearchCV(torch_model, search_space, n_iter=32, cv=cv)
    bayes_search.fit(X, y)  # 假设 X, y 是你的数据
    
    print("Best parameters found: ", bayes_search.best_params_)
    
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读