由于多数优化算法都是MATLAB代码，不容易与一些机器学习算法组合使用，如下是一些常见优化算法Python版本的代码，希望能帮到你。

灰狼优化算法代码

import numpy as np
import random
import copy

def initial(pop, dim, ub, lb):
    X = np.zeros([pop, dim])
    for i in range(pop):
        for j in range(dim):
            X[i, j] = random.random() * (ub[j] - lb[j]) + lb[j]

    return X, lb, ub

def BorderCheck(X, ub, lb, pop, dim):
    for i in range(pop):
        for j in range(dim):
            if X[i, j] > ub[j]:
                X[i, j] = ub[j]
            elif X[i, j] < lb[j]:
                X[i, j] = lb[j]
    return X

def CaculateFitness(X, fun):
    pop = X.shape[0]
    fitness = np.zeros([pop, 1])
    for i in range(pop):
        fitness[i] = fun(X[i, :])
    return fitness

def SortFitness(Fit):
    fitness = np.sort(Fit, axis=0)
    index = np.argsort(Fit, axis=0)
    return fitness, index

def SortPosition(X, index):
    Xnew = np.zeros(X.shape)
    for i in range(X.shape[0]):
        Xnew[i, :] = X[index[i], :]
    return Xnew

def GWO(pop, dim, lb, ub, MaxIter, fun):
   
    Alpha_pos=np.zeros([1,dim])
    Alpha_score = float("inf")
    Beta_pos=np.ones([1,dim])
    Beta_score = float("inf")
    Delta_pos=np.ones([1,dim])
    Delta_score = float("inf")
    
    
    X, lb, ub = initial(pop, dim, ub, lb)  # 初始化种群
    fitness = CaculateFitness(X, fun)  # 计算适应度值
    indexBest = np.argmin(fitness)
    GbestScore = copy.copy(fitness[indexBest])
    GbestPositon = np.zeros([1,dim])
    GbestPositon[0,:] = copy.copy(X[indexBest,:])
    Curve = np.zeros([MaxIter, 1])
    for t in range(MaxIter):
        
        for i in range(pop):            
            fitValue = fun(X[i,:])
            if fitValue<Alpha_score:
                Alpha_score = copy.copy(fitValue)
                Alpha_pos[0,:] = copy.copy(X[i,:])
            
            if fitValue>Alpha_score and fitValue<Beta_score:
                Beta_score = copy.copy(fitValue)
                Beta_pos[0,:] = copy.copy(X[i,:])
                
            if fitValue>Alpha_score and fitValue>Beta_score and fitValue<Delta_score:
                Delta_score = copy.copy(fitValue)
                Delta_pos[0,:] = copy.copy(X[i,:])
        
        a = 2 - t*(2/MaxIter)
        for i in range(pop):
            for j in range(dim):
                r1 = random.random()
                r2 = random.random()
                A1= 2*a*r1-a
                C1 = 2*r2
                
                D_alpha=np.abs(C1*Alpha_pos[0,j]-X[i,j])
                X1=Alpha_pos[0,j]-A1*D_alpha
                
                r1 = random.random()
                r2 = random.random()
                A2= 2*a*r1-a
                C2 = 2*r2
                
                D_beta=np.abs(C2*Beta_pos[0,j]-X[i,j])
                X2=Beta_pos[0,j]-A2*D_beta
                
                r1 = random.random()
                r2 = random.random()
                A3= 2*a*r1-a
                C3 = 2*r2
                D_beta=np.abs(C3*Delta_pos[0,j]-X[i,j])
                X3=Delta_pos[0,j]-A3*D_beta
                
                X[i,j] = (X1+X2+X3)/3
                
                  
        X = BorderCheck(X, ub, lb, pop, dim)  # 边界检测
        fitness = CaculateFitness(X, fun)  # 计算适应度值
        indexBest = np.argmin(fitness)
        if fitness[indexBest] <= GbestScore:  # 更新全局最优
            GbestScore = copy.copy(fitness[indexBest])
            GbestPositon[0,:] = copy.copy(X[indexBest, :])
        Curve[t] = GbestScore

    return GbestScore, GbestPositon, Curve