1、yalmip+cplex优化的微电网，含光伏、风电、蓄电池和电网。 2、粒子群算法优化的微电网。 粒子群算法优化的综合能源系统。 多目标算法优化的综合能源系统。 遗传算法。 基于遗传算法的光伏出力预测。 风光负荷典型场景生成程序。 拉丁超立方抽样。 拉丁超立方场景生成。 全部打包100元。 任选一个50元。 具体如下图。 注意以上不一定都完整，基本都有注释，大部分都有对应资料，适合基础学习。

在电力系统和能源领域，微电网与综合能源系统的优化一直是热门话题。今天就来和大家聊聊我最近发现的一些有意思的相关代码和算法资源，而且价格超实惠哦！

Yalmip + Cplex 优化的微电网

微电网包含光伏、风电、蓄电池和电网多种元素，其优化调度对于能源高效利用和成本控制至关重要。使用Yalmip结合Cplex求解器，我们可以实现对微电网的优化。

% 定义变量
sdpvar P_pv P_wind P_bat P_grid % 分别表示光伏、风电、蓄电池、电网的功率
% 约束条件
Constraints = [];
% 功率平衡约束
Constraints = [Constraints, P_load == P_pv + P_wind + P_bat + P_grid]; 
% 光伏功率限制
Constraints = [Constraints, 0 <= P_pv <= P_pv_max]; 
% 风电功率限制
Constraints = [Constraints, 0 <= P_wind <= P_wind_max]; 
% 蓄电池充放电功率限制
Constraints = [Constraints, -P_bat_max <= P_bat <= P_bat_max]; 
% 电网功率限制
Constraints = [Constraints, -P_grid_max <= P_grid <= P_grid_max]; 

% 目标函数，例如最小化成本
Cost = cost_pv * P_pv + cost_wind * P_wind + cost_bat * P_bat + cost_grid * P_grid;
Objective = minimize(Cost);

% 求解
ops = sdpsettings('solver', 'cplex');
sol = optimize(Constraints, Objective, ops);

% 输出结果
if sol.problem == 0
    disp('优化成功');
    disp(['光伏功率: ', num2str(double(P_pv))]);
    disp(['风电功率: ', num2str(double(P_wind))]);
    disp(['蓄电池功率: ', num2str(double(P_bat))]);
    disp(['电网功率: ', num2str(double(P_grid))]);
else
    disp('优化失败');
end

这段代码通过Yalmip定义了微电网中各部分功率的变量，设置了功率平衡、功率上下限等约束条件，以成本最小化为目标函数，最后调用Cplex求解器进行优化求解。

粒子群算法优化的微电网

粒子群算法（PSO）是一种基于群体智能的优化算法，在微电网优化中也能发挥很大作用。它模拟鸟群觅食行为，通过粒子之间的协作与竞争来寻找最优解。

import numpy as np

# 粒子群算法参数
n_particles = 50  # 粒子数量
n_dimensions = 4  # 维度，对应光伏、风电、蓄电池、电网功率
c1 = 1.5  # 学习因子1
c2 = 1.5  # 学习因子2
w = 0.7  # 惯性权重
max_iter = 100  # 最大迭代次数

# 初始化粒子位置和速度
particles = np.random.rand(n_particles, n_dimensions)
velocities = np.random.rand(n_particles, n_dimensions)

# 个体最优位置和适应度
pbest_positions = particles.copy()
pbest_fitness = np.array([cost_function(p) for p in particles])

# 全局最优位置和适应度
gbest_index = np.argmin(pbest_fitness)
gbest_position = pbest_positions[gbest_index]
gbest_fitness = pbest_fitness[gbest_index]

for i in range(max_iter):
    r1 = np.random.rand(n_particles, n_dimensions)
    r2 = np.random.rand(n_particles, n_dimensions)
    velocities = w * velocities + c1 * r1 * (pbest_positions - particles) + c2 * r2 * (gbest_position - particles)
    particles = particles + velocities

    fitness = np.array([cost_function(p) for p in particles])
    improved_indices = fitness < pbest_fitness
    pbest_positions[improved_indices] = particles[improved_indices]
    pbest_fitness[improved_indices] = fitness[improved_indices]

    current_best_index = np.argmin(pbest_fitness)
    if pbest_fitness[current_best_index] < gbest_fitness:
        gbest_fitness = pbest_fitness[current_best_index]
        gbest_position = pbest_positions[current_best_index]


def cost_function(position):
    P_pv, P_wind, P_bat, P_grid = position
    # 这里根据实际情况定义成本函数，例如与功率和成本系数相关的计算
    cost = cost_pv * P_pv + cost_wind * P_wind + cost_bat * P_bat + cost_grid * P_grid
    return cost

这段Python代码实现了粒子群算法对微电网功率分配的优化。在每一次迭代中，粒子根据自身经验（个体最优位置）和群体经验（全局最优位置）来更新自己的速度和位置，以寻找使成本函数最小化的功率分配方案。

粒子群算法优化的综合能源系统

综合能源系统比微电网更为复杂，涵盖多种能源形式。粒子群算法同样可用于其优化。与微电网优化类似，我们需要定义合适的变量、目标函数和约束条件。

% 假设有电、热、气等多种能源变量
sdpvar P_electric P_heat P_gas
% 约束条件，例如能源转换和需求平衡约束
Constraints = [];
Constraints = [Constraints, Demand_electric == Conversion_electric(P_gas) + P_electric];
Constraints = [Constraints, Demand_heat == Conversion_heat(P_gas) + P_heat];

% 目标函数，例如最小化总成本或碳排放
Cost = cost_electric * P_electric + cost_heat * P_heat + cost_gas * P_gas;
Objective = minimize(Cost);

% 结合粒子群算法进行优化，这里简单示意
% 初始化粒子
particles = rand(n_particles, 3); % 3个变量对应电、热、气
for iter = 1:max_iter
    for i = 1:n_particles
        % 计算适应度
        fitness(i) = double(Cost);
        % 更新个体最优和全局最优
        if fitness(i) < pbest_fitness(i)
            pbest_fitness(i) = fitness(i);
            pbest_positions(i, :) = particles(i, :);
        end
        if fitness(i) < gbest_fitness
            gbest_fitness = fitness(i);
            gbest_position = particles(i, :);
        end
    end
    % 更新粒子速度和位置
    velocities = w * velocities + c1 * rand(n_particles, 3).*(pbest_positions - particles) + c2 * rand(n_particles, 3).*(gbest_position - particles);
    particles = particles + velocities;
end

这段Matlab代码展示了在综合能源系统优化中，如何结合Yalmip和粒子群算法。通过定义不同能源的变量和相关约束，以成本最小化为目标，利用粒子群算法寻找最优的能源分配策略。

多目标算法优化的综合能源系统

多目标优化在综合能源系统中更贴合实际需求，因为往往需要同时考虑成本、环境影响、可靠性等多个目标。例如使用NSGA - II算法（非支配排序遗传算法 - II）。

import numpy as np
from pymoo.algorithms.moo.nsga2 import NSGA2
from pymoo.factory import get_problem, get_sampling, get_crossover, get_mutation
from pymoo.optimize import minimize


# 定义综合能源系统的多目标问题
class EnergySystemProblem:
    def __init__(self):
        self.n_var = 3  # 例如电、热、气变量数量
        self.n_obj = 2  # 两个目标，如成本和碳排放
        self.n_constr = 0

    def _evaluate(self, x, out, *args, **kwargs):
        P_electric, P_heat, P_gas = x
        cost = cost_electric * P_electric + cost_heat * P_heat + cost_gas * P_gas
        carbon_emission = emission_electric * P_electric + emission_heat * P_heat + emission_gas * P_gas
        out["F"] = np.column_stack([cost, carbon_emission])


problem = EnergySystemProblem()
algorithm = NSGA2(
    pop_size=100,
    sampling=get_sampling("real_random"),
    crossover=get_crossover("real_sbx", prob=0.9, eta=15),
    mutation=get_mutation("real_pm", eta=20)
)
res = minimize(problem,
               algorithm,
               ('n_gen', 50),
               seed=1,
               verbose=False)

这段Python代码利用pymoo库实现了NSGA - II算法对综合能源系统的多目标优化。定义了一个能源系统问题类，包含变量、目标和约束信息，通过NSGA - II算法寻找在成本和碳排放等目标之间的最优权衡解。

遗传算法

遗传算法（GA）是一种模拟自然选择和遗传机制的优化算法。它通过选择、交叉和变异等操作，在解空间中搜索最优解。

import numpy as np


# 遗传算法参数
population_size = 50  # 种群大小
chromosome_length = 10  # 染色体长度
generations = 50  # 世代数
mutation_rate = 0.01  # 变异率

# 初始化种群
population = np.random.randint(0, 2, size=(population_size, chromosome_length))


def fitness_function(chromosome):
    # 将二进制染色体转换为实际数值
    value = int(''.join(map(str, chromosome)), 2)
    # 根据实际问题定义适应度函数，例如与某个目标相关的计算
    fitness = 1 / (1 + np.abs(value - target_value))
    return fitness


for generation in range(generations):
    fitness_values = np.array([fitness_function(chromosome) for chromosome in population])
    total_fitness = np.sum(fitness_values)
    selection_probabilities = fitness_values / total_fitness

    new_population = []
    for _ in range(population_size):
        parent1 = population[np.random.choice(population_size, p=selection_probabilities)]
        parent2 = population[np.random.choice(population_size, p=selection_probabilities)]

        crossover_point = np.random.randint(1, chromosome_length - 1)
        child = np.concatenate((parent1[:crossover_point], parent2[crossover_point:]))

        for i in range(chromosome_length):
            if np.random.rand() < mutation_rate:
                child[i] = 1 - child[i]

        new_population.append(child)

    population = np.array(new_population)

这段代码展示了简单遗传算法的实现过程。通过初始化种群，计算每个个体的适应度，基于适应度进行选择、交叉和变异操作，不断进化种群以寻找最优解。

基于遗传算法的光伏出力预测

光伏出力受多种因素影响，准确预测有助于微电网的优化调度。遗传算法可用于优化预测模型的参数。

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error


# 读取数据
data = pd.read_csv('solar_data.csv')
X = data[['temperature', 'irradiance']]
y = data['solar_output']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# 定义遗传算法优化的目标函数，最小化均方误差
def fitness_function(params):
    lr = LinearRegression()
    lr.coef_ = params[:-1]
    lr.intercept_ = params[-1]
    y_pred = lr.predict(X_train)
    mse = mean_squared_error(y_train, y_pred)
    return 1 / (1 + mse)


# 遗传算法参数
population_size = 30
chromosome_length = X_train.shape[1] + 1  # 系数数量加截距
generations = 50
mutation_rate = 0.01

# 初始化种群
population = np.random.randn(population_size, chromosome_length)


for generation in range(generations):
    fitness_values = np.array([fitness_function(chromosome) for chromosome in population])
    total_fitness = np.sum(fitness_values)
    selection_probabilities = fitness_values / total_fitness

    new_population = []
    for _ in range(population_size):
        parent1 = population[np.random.choice(population_size, p=selection_probabilities)]
        parent2 = population[np.random.choice(population_size, p=selection_probabilities)]

        crossover_point = np.random.randint(1, chromosome_length - 1)
        child = np.concatenate((parent1[:crossover_point], parent2[crossover_point:]))

        for i in range(chromosome_length):
            if np.random.rand() < mutation_rate:
                child[i] = child[i] + np.random.randn()

        new_population.append(child)

    population = np.array(new_population)

best_params = population[np.argmax([fitness_function(chromosome) for chromosome in population])]
lr = LinearRegression()
lr.coef_ = best_params[:-1]
lr.intercept_ = best_params[-1]
y_pred = lr.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print(f'测试集均方误差: {mse}')

此代码利用遗传算法优化线性回归模型的参数，以提高光伏出力预测的准确性。通过在训练集上不断优化参数，使模型在测试集上达到较好的预测效果。

风光负荷典型场景生成程序

风光负荷的不确定性给微电网和综合能源系统的分析带来挑战，典型场景生成可以简化分析。这里介绍拉丁超立方抽样相关的场景生成方法。

拉丁超立方抽样

拉丁超立方抽样（LHS）是一种分层抽样方法，能在较少样本下更好地覆盖变量空间。

import numpy as np


def latin_hypercube_sampling(n_samples, n_dimensions):
    samples = np.zeros((n_samples, n_dimensions))
    intervals = np.linspace(0, 1, n_samples + 1)

    for j in range(n_dimensions):
        sample_order = np.random.permutation(n_samples)
        for i in range(n_samples):
            samples[i, j] = np.random.uniform(intervals[sample_order[i]], intervals[sample_order[i] + 1])

    return samples


n_samples = 100
n_dimensions = 3  # 例如光伏、风电、负荷维度
samples = latin_hypercube_sampling(n_samples, n_dimensions)

这段代码实现了拉丁超立方抽样，在给定样本数量和维度的情况下，生成在每个维度上均匀分布且不重复的样本点。

拉丁超立方场景生成

基于拉丁超立方抽样，可以进一步生成风光负荷的典型场景。

import pandas as pd
import numpy as np


# 假设已有光伏、风电、负荷的历史数据
solar_data = pd.read_csv('solar_history.csv')['solar_output']
wind_data = pd.read_csv('wind_history.csv')['wind_output']
load_data = pd.read_csv('load_history.csv')['load']

n_scenarios = 10
n_dimensions = 3  # 光伏、风电、负荷

lhs_samples = latin_hypercube_sampling(n_scenarios, n_dimensions)

scenarios = []
for sample in lhs_samples:
    solar_scenario = np.percentile(solar_data, sample[0] * 100)
    wind_scenario = np.percentile(wind_data, sample[1] * 100)
    load_scenario = np.percentile(load_data, sample[2] * 100)
    scenarios.append([solar_scenario, wind_scenario, load_scenario])

scenarios_df = pd.DataFrame(scenarios, columns=['Solar', 'Wind', 'Load'])
print(scenarios_df)

这段代码结合拉丁超立方抽样生成的样本，从历史数据中提取相应的分位数，从而生成风光负荷的典型场景，可用于后续的微电网或综合能源系统分析。

1、yalmip+cplex优化的微电网，含光伏、风电、蓄电池和电网。 2、粒子群算法优化的微电网。 粒子群算法优化的综合能源系统。 多目标算法优化的综合能源系统。 遗传算法。 基于遗传算法的光伏出力预测。 风光负荷典型场景生成程序。 拉丁超立方抽样。 拉丁超立方场景生成。 全部打包100元。 任选一个50元。 具体如下图。 注意以上不一定都完整，基本都有注释，大部分都有对应资料，适合基础学习。

最后，给大家说个福利，上面提到的这些代码和相关资料，全部打包只要100元，任选一个就是50元。这些代码基本都有注释，大部分还有对应资料，非常适合基础学习，无论是刚接触微电网和综合能源系统的小白，还是想深入研究优化算法的同学，都是不错的选择哦！感兴趣的小伙伴可以进一步了解~