主题065：机器学习辅助电磁设计

目录

1. 引言
2. 机器学习基础
3. 神经网络代理模型
4. 数据驱动优化
5. 深度学习逆设计
6. 生成模型应用
7. Python实现与案例
8. 总结与展望

---

引言

1.1 传统电磁设计的挑战

电磁器件设计是一个复杂的多参数优化问题，传统方法面临以下挑战：

计算成本高昂

• 全波电磁仿真（如FDTD、FEM）每次计算可能需要数分钟到数小时
• 优化过程需要成千上万次仿真迭代
• 高维参数空间探索计算量巨大

设计空间复杂

• 电磁响应与几何参数通常呈非线性关系
• 存在多个局部最优解
• 参数间存在强耦合效应

经验依赖性强

• 需要丰富的领域知识
• 设计周期漫长
• 难以发现非直观的最优结构

1.2 机器学习的优势

机器学习为电磁设计带来革命性变革：

加速计算

• 训练后的神经网络可在毫秒级预测电磁响应
• 相比传统仿真加速100-10000倍
• 实现实时优化和交互式设计

挖掘隐藏模式

• 从大量数据中学习参数-响应映射
• 发现人类难以察觉的设计规律
• 支持高维复杂设计空间探索

自动化设计

• 减少人工试错
• 实现端到端优化
• 支持多目标、多约束优化

1.3 本章内容概述

本章系统介绍机器学习在电磁设计中的应用：

• 神经网络代理模型：用神经网络替代耗时的电磁仿真
• 数据驱动优化：结合代理模型进行高效优化
• 深度学习逆设计：从目标响应直接预测最优结构
• 生成模型应用：使用GAN、VAE生成创新设计

---

机器学习基础

2.1 监督学习基础

2.1.1 回归问题

电磁设计中，回归问题用于预测连续响应：

问题定义
给定输入参数 $\mathbf{x}\in {\mathbb{R}}^d$（如天线尺寸、材料参数），预测输出响应 $y\in \mathbb{R}$（如谐振频率、增益、S参数）。

数学表达
寻找映射函数 $f:{\mathbb{R}}^d\to \mathbb{R}$，使得：

$$y=f(\mathbf{x})+ϵ$$

其中 $ϵ$ 是噪声项。

损失函数
均方误差（MSE）是最常用的回归损失：

$${\mathcal{L}}_{MSE}=\frac{1}{N}\sum _{i=1}^N(y_i-{\hat{y}}_i{)}^2$$

电磁应用示例

• 预测微带天线谐振频率
• 估计波导传输损耗
• 计算阵列天线波束宽度

2.1.2 分类问题

分类用于离散决策：

二分类问题
判断设计是否满足规格：

$$P(\text{合格}|\mathbf{x})=\sigma (f(\mathbf{x}))$$

其中 $\sigma$ 是sigmoid函数。

多分类问题
选择最佳设计类型：

$$P(y=k|\mathbf{x})=\frac{e^{f_k(\mathbf{x})}}{{\sum }_j{e}^{f_j(\mathbf{x})}}$$

使用softmax函数。

电磁应用示例

• 判断天线是否满足带宽要求
• 选择最优天线类型（偶极子、微带、缝隙）
• 识别电磁干扰模式

2.2 神经网络架构

2.2.1 全连接神经网络（FNN）

基本结构

全连接神经网络由多层神经元组成：

输入层 → 隐藏层1 → 隐藏层2 → ... → 输出层

前向传播

第 $l$ 层的输出：

$${\mathbf{z}}^{[l]}={\mathbf{W}}^{[l]}{\mathbf{a}}^{[l-1]}+{\mathbf{b}}^{[l]}$$
$${\mathbf{a}}^{[l]}=g({\mathbf{z}}^{[l]})$$

其中：

• ${\mathbf{W}}^{[l]}$：权重矩阵
• ${\mathbf{b}}^{[l]}$：偏置向量
• $g(\cdot )$：激活函数

激活函数

激活函数	表达式	特点
ReLU	$g(z)=\max (0,z)$	计算简单，缓解梯度消失
Sigmoid	$g(z)=\frac{1}{1+e^{-z}}$	输出(0,1)，适合分类
Tanh	$g(z)=\frac{e^z-e^{-z}}{e^z+e^{-z}}$	输出(-1,1)，零中心化
Leaky ReLU	$g(z)=\max (\alpha z,z)$	解决ReLU死亡问题

反向传播

计算损失函数对参数的梯度：

$$\frac{\partial \mathcal{L}}{\partial {\mathbf{W}}^{[l]}}=\frac{\partial \mathcal{L}}{\partial {\mathbf{z}}^{[l]}}\cdot \frac{\partial {\mathbf{z}}^{[l]}}{\partial {\mathbf{W}}^{[l]}}={\mathbf{\delta }}^{[l]}\cdot ({\mathbf{a}}^{[l-1]}{)}^T$$

其中误差项：

$${\mathbf{\delta }}^{[l]}=\frac{\partial \mathcal{L}}{\partial {\mathbf{z}}^{[l]}}=({\mathbf{W}}^{[l+1]}{)}^T{\mathbf{\delta }}^{[l+1]}\odot g^{\prime }({\mathbf{z}}^{[l]})$$

2.2.2 卷积神经网络（CNN）

CNN特别适合处理具有空间结构的电磁数据：

卷积操作

$$\mathbf{Y}[i,j]=\sum _m\sum _n\mathbf{X}[i+m,j+n]\cdot \mathbf{K}[m,n]$$

其中 $\mathbf{K}$ 是卷积核。

电磁应用

• 分析天线电流分布图像
• 处理近场扫描数据
• 识别散射场模式

优势

• 参数共享减少计算量
• 平移不变性
• 自动特征提取

2.2.3 循环神经网络（RNN）

RNN适合处理序列数据：

基本结构

$${\mathbf{h}}_t=g({\mathbf{W}}_{hh}{\mathbf{h}}_{t-1}+{\mathbf{W}}_{xh}{\mathbf{x}}_t+{\mathbf{b}}_h)$$
$${\mathbf{y}}_t={\mathbf{W}}_{hy}{\mathbf{h}}_t+{\mathbf{b}}_y$$

电磁应用

• 预测时域电磁响应
• 分析频率扫描数据
• 处理宽带天线响应

2.3 训练与优化

2.3.1 数据集划分

训练集/验证集/测试集

典型划分比例：70% / 15% / 15%

数据预处理

标准化：

$${\mathbf{x}}_{norm}=\frac{\mathbf{x}-\mu }{\sigma }$$

归一化：

$${\mathbf{x}}_{scaled}=\frac{\mathbf{x}-{\mathbf{x}}_{min}}{{\mathbf{x}}_{max}-{\mathbf{x}}_{min}}$$

2.3.2 优化算法

随机梯度下降（SGD）

$$\mathbf{W}\leftarrow \mathbf{W}-\eta {\nabla }_{\mathbf{W}}\mathcal{L}$$

Adam优化器

结合动量和自适应学习率：

$$m_t={\beta }_1{m}_{t-1}+(1-{\beta }_1)g_t$$
$$v_t={\beta }_2{v}_{t-1}+(1-{\beta }_2)g_t^2$$
$${\hat{m}}_t=\frac{m_t}{1-{\beta }_1^t},{\hat{v}}_t=\frac{v_t}{1-{\beta }_2^t}$$
$$\mathbf{W}\leftarrow \mathbf{W}-\eta \frac{{\hat{m}}_t}{\sqrt{{\hat{v}}_t}+ϵ}$$

2.3.3 正则化技术

L2正则化（权重衰减）

$${\mathcal{L}}_{total}={\mathcal{L}}_{data}+\lambda \sum _i{w}_i^2$$

Dropout

训练时随机丢弃神经元，防止过拟合：

$${\mathbf{a}}^{[l]}={\mathbf{a}}^{[l]}\odot \mathbf{m},m_i\sim \text{Bernoulli}(p)$$

早停（Early Stopping）

监控验证集损失，在过拟合前停止训练。

---

神经网络代理模型

3.1 代理模型概念

3.1.1 什么是代理模型

代理模型（Surrogate Model）是用计算成本低的近似模型替代昂贵的仿真或实验：

传统仿真

参数 → [电磁仿真软件] → 响应 (数分钟~数小时)

代理模型

参数 → [神经网络] → 响应 (毫秒级)

3.1.2 代理模型类型

类型	优点	缺点
多项式回归	简单、可解释	高维效果差
高斯过程	提供不确定性估计	大数据集慢
径向基函数	插值能力强	需要调参
神经网络	表达能力强、快速	需要大量数据

3.2 神经网络代理模型构建

3.2.1 数据生成策略

采样方法

1. 拉丁超立方采样（LHS）

   • 将参数空间均匀划分
   • 确保样本覆盖整个空间
   • 适合初始数据集

2. 自适应采样

   • 在预测不确定性高的区域增加样本
   • 提高模型精度
   • 减少总样本数

数据增强

对于电磁问题，可利用物理对称性：

• 几何对称性
• 频率缩放
• 互易性

3.2.2 网络架构设计

输入层设计

输入维度等于设计参数数量：

# 微带天线参数：L, W, h, epsilon_r
input_dim = 4

隐藏层设计

经验法则：

• 层数：2-5层
• 每层神经元：输入维度的2-10倍
• 使用递减结构（如：64→32→16）

输出层设计

根据预测目标：

• 单输出：回归问题
• 多输出：多频点响应、S参数

3.2.3 训练策略

损失函数选择

# 回归问题
loss_fn = nn.MSELoss()

# 相对误差
class RelativeMSELoss(nn.Module):
    def forward(self, pred, target):
        return torch.mean(((pred - target) / target) ** 2)

学习率调度

scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
    optimizer, mode='min', factor=0.5, patience=10
)

3.3 代理模型评估

3.3.1 精度指标

均方根误差（RMSE）

$$RMSE=\sqrt{\frac{1}{N}\sum _{i=1}^N(y_i-{\hat{y}}_i{)}^2}$$

平均绝对百分比误差（MAPE）

$$MAPE=\frac{100\%}{N}\sum _{i=1}^N\left|\frac{y_i-{\hat{y}}_i}{y_i}\right|$$

决定系数（R²）

$$R^2=1-\frac{{\sum }_i(y_i-{\hat{y}}_i{)}^2}{{\sum }_i(y_i-\bar{y}{)}^2}$$

3.3.2 验证方法

K折交叉验证

将数据分为K份，轮流作为验证集：

$$CV=\frac{1}{K}\sum _{k=1}^K{\mathcal{L}}_k$$

留一法（LOO）

每次留一个样本作为验证集，适合小数据集。

3.4 应用案例：天线谐振频率预测

3.4.1 问题描述

预测矩形微带天线的谐振频率：

输入参数

• 贴片长度 $L$ (mm)
• 贴片宽度 $W$ (mm)
• 基板厚度 $h$ (mm)
• 介电常数 ${ϵ}_r$

输出

• 谐振频率 $f_r$ (GHz)

3.4.2 理论模型

经典近似公式：

$$f_r=\frac{c}{2L_e\sqrt{{ϵ}_{eff}}}$$

其中：

$${ϵ}_{eff}=\frac{{ϵ}_r+1}{2}+\frac{{ϵ}_r-1}{2}(1+\frac{12h}{W}{)}^{-1/2}$$

$$L_e=L+2\Delta L$$

$$\Delta L=0.412h\frac{({ϵ}_{eff}+0.3)(W/h+0.264)}{({ϵ}_{eff}-0.258)(W/h+0.8)}$$

3.4.3 神经网络模型

网络结构

Input(4) → Dense(64, ReLU) → Dense(32, ReLU) → Dense(16, ReLU) → Output(1)

训练结果

指标	数值
RMSE	0.05 GHz
MAPE	1.2%
R²	0.998

速度对比

方法	单次预测时间
全波仿真	5-10分钟
理论公式	<1毫秒
神经网络	<1毫秒

神经网络精度接近全波仿真，速度提升10000倍！

---

数据驱动优化

4.1 代理模型辅助优化

4.1.1 优化框架

结合代理模型和进化算法：

循环：
  1. 用代理模型快速评估候选解
  2. 选择最优候选进行精确仿真验证
  3. 将验证结果加入训练集
  4. 更新代理模型

4.1.2 高效全局优化（EGO）

采集函数

平衡探索与利用：

$$EI(x)=E[\max (f(x^{\ast })-f(x),0)]$$

其中 $f(x^{\ast })$ 是当前最优值。

对于高斯过程代理：

$$EI(x)=(\mu (x)-f(x^{\ast }))\Phi (Z)+\sigma (x)\varphi (Z)$$

$$Z=\frac{\mu (x)-f(x^{\ast })}{\sigma (x)}$$

4.2 神经网络加速遗传算法

4.2.1 算法流程

def neural_ga_optimization():
    # 初始化
    population = initialize_population()
    
    # 初始精确评估
    fitness_exact = [exact_simulation(ind) for ind in population]
    
    # 训练代理模型
    surrogate = train_neural_network(population, fitness_exact)
    
    for generation in range(max_gen):
        # 使用代理模型快速评估
        fitness_surrogate = [surrogate.predict(ind) for ind in population]
        
        # 选择
        parents = selection(population, fitness_surrogate)
        
        # 交叉和变异
        offspring = crossover_and_mutation(parents)
        
        # 选择部分个体进行精确评估
        to_evaluate = select_for_exact_evaluation(offspring, surrogate)
        fitness_new = [exact_simulation(ind) for ind in to_evaluate]
        
        # 更新代理模型
        surrogate.update(to_evaluate, fitness_new)
        
        population = offspring
    
    return best_solution

4.2.2 自适应选择策略

基于不确定性的选择

优先选择代理模型预测不确定性高的个体：

$$U(x)=\text{Var}[f(x)]$$

基于改进期望的选择

选择可能带来最大改进的个体：

$$PI(x)=P(f(x)<f(x^{\ast }))$$

4.3 多目标优化

4.3.1 帕累托最优

多目标优化问题：

$$\underset{\mathbf{x}}{\min }\mathbf{f}(\mathbf{x})=[f_1(\mathbf{x}),f_2(\mathbf{x}),...,f_m(\mathbf{x})]$$

帕累托支配

解 ${\mathbf{x}}_1$ 支配 ${\mathbf{x}}_2$ 当且仅当：

$$\forall i:f_i({\mathbf{x}}_1)\le f_i({\mathbf{x}}_2)\wedge \exists j:f_j({\mathbf{x}}_1)<f_j({\mathbf{x}}_2)$$

4.3.2 NSGA-II算法

非支配排序

将种群分为多个非支配前沿：

$$F_1\succ F_2\succ F_3\succ ...$$

拥挤距离

维护解的多样性：

$$C{D}_i=\sum _m\frac{f_m^{i+1}-f_m^{i-1}}{f_m^{max}-f_m^{min}}$$

结合代理模型

用神经网络代理模型快速评估非支配排序，仅在必要时进行精确仿真。

4.4 应用案例：多频带天线优化

4.4.1 设计目标

优化三频带微带天线：

目标

• 最小化反射系数在三个频段：$f_1=2.4$ GHz, $f_2=3.5$ GHz, $f_3=5.8$ GHz
• 最大化增益

约束

• 天线尺寸限制
• 带宽要求

4.4.2 优化结果

收敛曲线

代理模型辅助优化相比传统方法：

• 精确仿真调用次数减少80%
• 总优化时间从3天减少到2小时
• 找到相同质量的最优解

帕累托前沿

获得多个权衡方案供设计者选择。

---

深度学习逆设计

5.1 逆问题定义

5.1.1 正向vs逆向

正向问题

结构参数 → [电磁仿真] → 响应

已知：几何结构、材料参数
求解：电磁响应（S参数、场分布）

逆向问题

目标响应 → [逆设计] → 结构参数

已知：期望的电磁响应
求解：最优结构参数

5.1.2 逆问题的挑战

不适定性

• 多对一映射：不同结构可能产生相似响应
• 解不唯一
• 对噪声敏感

非线性

• 响应与参数高度非线性
• 传统优化容易陷入局部最优

5.2 串联神经网络（Tandem Network）

5.2.1 架构设计

串联网络结合正向和逆向模型：

目标响应 → [逆网络] → 预测参数 → [正向网络] → 预测响应

训练策略

1. 先训练正向网络（监督学习）
2. 固定正向网络，训练逆网络
3. 端到端微调

损失函数

$$\mathcal{L}={\mathcal{L}}_{param}+\lambda {\mathcal{L}}_{response}$$

其中：

• ${\mathcal{L}}_{param}$：参数预测损失
• ${\mathcal{L}}_{response}$：响应重建损失

5.2.2 实现细节

正向网络

class ForwardNetwork(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, output_dim)
        )
    
    def forward(self, x):
        return self.net(x)

逆网络

class InverseNetwork(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, output_dim)
        )
    
    def forward(self, y):
        return self.net(y)

5.3 条件生成模型

5.3.1 条件变分自编码器（CVAE）

VAE基础

变分自编码器学习潜在表示：

$${\mathcal{L}}_{VAE}={\mathcal{L}}_{recon}+\beta \cdot KL(q(z|x)||p(z))$$

条件VAE

将目标响应作为条件：

$$q(z|x,y),p(x|z,y)$$

采样生成

从潜在空间采样生成多样设计：

$$z\sim \mathcal{N}(0,I)$$
$$x=\text{Decoder}(z,y)$$

5.3.2 条件生成对抗网络（CGAN）

GAN框架

生成器 $G$ 和判别器 $D$ 的对抗：

$$\underset{G}{\min }\underset{D}{\max }V(D,G)=\mathbb{E}[\log D(x|y)]+\mathbb{E}[\log (1-D(G(z|y)))]$$

条件生成

将目标响应 $y$ 作为条件输入生成器和判别器。

5.4 应用案例：超表面单元设计

5.4.1 问题描述

设计超表面单元实现目标相位响应：

输入

• 目标相位：${\varphi }_{target}(f)$ 在多个频点

输出

• 单元几何参数：$[L_1,L_2,W,g]$

5.4.2 串联网络结果

训练数据

• 10000个随机几何结构
• 全波仿真获取相位响应

测试性能

指标	数值
相位误差	<10°
设计成功率	85%
单次设计时间	<10毫秒

优势

• 避免迭代优化
• 一次前向传播获得设计
• 支持实时设计

---

生成模型应用

6.1 生成对抗网络（GAN）

6.1.1 GAN原理

对抗训练

生成器 $G$ 试图欺骗判别器 $D$：

G: z → 假样本
D: 样本 → 真假概率

损失函数

判别器损失：
$${\mathcal{L}}_D=-\mathbb{E}[\log D(x)]-\mathbb{E}[\log (1-D(G(z)))]$$

生成器损失：
$${\mathcal{L}}_G=-\mathbb{E}[\log D(G(z))]$$

6.1.2 电磁设计应用

创新结构生成

生成新颖的天线或超表面结构：

# 从随机噪声生成设计
z = torch.randn(batch_size, latent_dim)
fake_designs = generator(z)

设计空间探索

在潜在空间插值发现过渡结构：

$$x_{interp}=G(\alpha z_1+(1-\alpha )z_2)$$

6.2 变分自编码器（VAE）

6.2.1 VAE架构

编码器

$$q_{\varphi }(z|x)=\mathcal{N}(z;{\mu }_{\varphi }(x),{\sigma }_{\varphi }^2(x))$$

解码器

$$p_{\theta }(x|z)$$

重参数化技巧

$$z=\mu +\sigma \odot ϵ,ϵ\sim \mathcal{N}(0,I)$$

6.2.2 潜在空间分析

结构插值

在潜在空间平滑过渡：

$$z_{mid}=\frac{z_1+z_2}{2}$$

属性编辑

沿特定方向移动改变结构属性：

$$z_{new}=z+\alpha \cdot \text{direction}$$

6.3 扩散模型

6.3.1 扩散过程

前向扩散

逐步添加噪声：

$$q(x_t|x_{t-1})=\mathcal{N}(x_t;\sqrt{1-{\beta }_t}{x}_{t-1},{\beta }_{t}I)$$

反向去噪

学习去噪：

$$p_{\theta }(x_{t-1}|x_t)=\mathcal{N}(x_{t-1};{\mu }_{\theta }(x_t,t),{\Sigma }_{\theta }(x_t,t))$$

6.3.2 条件扩散

将目标响应作为条件：

$$p_{\theta }(x_{t-1}|x_t,y)$$

优势

• 生成质量高
• 训练稳定
• 支持条件生成

6.4 应用案例：天线拓扑生成

6.4.1 问题描述

生成满足目标S参数的天线拓扑：

输入

• 目标S11曲线
• 设计约束（尺寸、材料）

输出

• 天线拓扑（二值图像）

6.4.2 VAE实现

编码器

class Encoder(nn.Module):
    def __init__(self, input_channels, latent_dim):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(input_channels, 32, 4, 2, 1),
            nn.ReLU(),
            nn.Conv2d(32, 64, 4, 2, 1),
            nn.ReLU(),
            nn.Conv2d(64, 128, 4, 2, 1),
            nn.ReLU(),
        )
        self.fc_mu = nn.Linear(128*8*8, latent_dim)
        self.fc_logvar = nn.Linear(128*8*8, latent_dim)
    
    def forward(self, x):
        h = self.conv(x)
        h = h.view(h.size(0), -1)
        mu = self.fc_mu(h)
        logvar = self.fc_logvar(h)
        return mu, logvar

解码器

class Decoder(nn.Module):
    def __init__(self, latent_dim, output_channels):
        super().__init__()
        self.fc = nn.Linear(latent_dim, 128*8*8)
        self.deconv = nn.Sequential(
            nn.ConvTranspose2d(128, 64, 4, 2, 1),
            nn.ReLU(),
            nn.ConvTranspose2d(64, 32, 4, 2, 1),
            nn.ReLU(),
            nn.ConvTranspose2d(32, output_channels, 4, 2, 1),
            nn.Sigmoid()
        )
    
    def forward(self, z):
        h = self.fc(z)
        h = h.view(h.size(0), 128, 8, 8)
        x = self.deconv(h)
        return x

6.4.3 生成结果

多样性

从潜在空间采样生成多种拓扑结构。

可控制性

通过条件输入控制生成结构的属性。

---

Python实现与案例

7.1 环境配置

import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import matplotlib.animation as animation

# 设置随机种子
torch.manual_seed(42)
np.random.seed(42)

7.2 案例1：微带天线谐振频率预测

7.2.1 数据生成

def generate_patch_antenna_data(n_samples=5000):
    """生成微带天线数据集"""
    # 随机采样参数
    L = np.random.uniform(20, 40, n_samples)  # mm
    W = np.random.uniform(30, 50, n_samples)  # mm
    h = np.random.uniform(0.5, 3.0, n_samples)  # mm
    epsilon_r = np.random.uniform(2.0, 10.0, n_samples)
    
    # 计算谐振频率（使用近似公式）
    c = 3e8  # 光速
    
    f_res = []
    for i in range(n_samples):
        # 有效介电常数
        if W[i]/h[i] <= 1:
            ee = (epsilon_r[i] + 1)/2 + (epsilon_r[i] - 1)/2 * \
                 ((1 + 12*h[i]/W[i])**(-0.5) + 0.04*(1 - W[i]/h[i])**2)
        else:
            ee = (epsilon_r[i] + 1)/2 + (epsilon_r[i] - 1)/2 * \
                 (1 + 12*h[i]/W[i])**(-0.5)
        
        # 边缘延伸
        delta_L = 0.412 * h[i] * (ee + 0.3) * (W[i]/h[i] + 0.264) / \
                  ((ee - 0.258) * (W[i]/h[i] + 0.8))
        
        Le = L[i] + 2 * delta_L
        
        # 谐振频率 (GHz)
        fr = c / (2 * Le * 1e-3 * np.sqrt(ee)) / 1e9
        f_res.append(fr)
    
    X = np.column_stack([L, W, h, epsilon_r])
    y = np.array(f_res)
    
    return X, y

# 生成数据
X, y = generate_patch_antenna_data(5000)

# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 标准化
scaler_X = StandardScaler()
scaler_y = StandardScaler()

X_train_scaled = scaler_X.fit_transform(X_train)
X_test_scaled = scaler_X.transform(X_test)
y_train_scaled = scaler_y.fit_transform(y_train.reshape(-1, 1)).flatten()
y_test_scaled = scaler_y.transform(y_test.reshape(-1, 1)).flatten()

7.2.2 神经网络模型

class AntennaFrequencyPredictor(nn.Module):
    def __init__(self, input_dim=4, hidden_dims=[64, 32, 16], output_dim=1):
        super().__init__()
        
        layers = []
        prev_dim = input_dim
        
        for hidden_dim in hidden_dims:
            layers.extend([
                nn.Linear(prev_dim, hidden_dim),
                nn.ReLU(),
                nn.Dropout(0.1)
            ])
            prev_dim = hidden_dim
        
        layers.append(nn.Linear(prev_dim, output_dim))
        
        self.network = nn.Sequential(*layers)
    
    def forward(self, x):
        return self.network(x)

# 创建模型
model = AntennaFrequencyPredictor()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
    optimizer, mode='min', factor=0.5, patience=10
)

# 转换为tensor
X_train_tensor = torch.FloatTensor(X_train_scaled)
y_train_tensor = torch.FloatTensor(y_train_scaled).reshape(-1, 1)
X_test_tensor = torch.FloatTensor(X_test_scaled)
y_test_tensor = torch.FloatTensor(y_test_scaled).reshape(-1, 1)

# 训练
train_losses = []
val_losses = []

for epoch in range(200):
    model.train()
    optimizer.zero_grad()
    
    outputs = model(X_train_tensor)
    loss = criterion(outputs, y_train_tensor)
    
    loss.backward()
    optimizer.step()
    
    # 验证
    model.eval()
    with torch.no_grad():
        val_outputs = model(X_test_tensor)
        val_loss = criterion(val_outputs, y_test_tensor)
    
    train_losses.append(loss.item())
    val_losses.append(val_loss.item())
    
    scheduler.step(val_loss)
    
    if (epoch + 1) % 20 == 0:
        print(f'Epoch [{epoch+1}/200], Train Loss: {loss.item():.6f}, Val Loss: {val_loss.item():.6f}')

7.2.3 结果评估

# 预测
model.eval()
with torch.no_grad():
    y_pred_scaled = model(X_test_tensor).numpy()
    y_pred = scaler_y.inverse_transform(y_pred_scaled).flatten()

# 计算指标
mse = np.mean((y_test - y_pred)**2)
rmse = np.sqrt(mse)
mape = np.mean(np.abs((y_test - y_pred) / y_test)) * 100
r2 = 1 - np.sum((y_test - y_pred)**2) / np.sum((y_test - np.mean(y_test))**2)

print(f"RMSE: {rmse:.4f} GHz")
print(f"MAPE: {mape:.2f}%")
print(f"R²: {r2:.4f}")

7.3 案例2：串联网络逆设计

7.3.1 数据准备

# 使用之前生成的数据
# 正向：参数 -> 频率
# 逆向：频率 -> 参数

# 添加一些噪声模拟真实仿真
y_noisy = y + np.random.normal(0, 0.05, len(y))

# 划分数据
X_train, X_test, y_train, y_test = train_test_split(
    X, y_noisy, test_size=0.2, random_state=42
)

# 标准化
scaler_X = StandardScaler()
scaler_y = StandardScaler()

X_train_scaled = scaler_X.fit_transform(X_train)
X_test_scaled = scaler_X.transform(X_test)
y_train_scaled = scaler_y.fit_transform(y_train.reshape(-1, 1)).flatten()
y_test_scaled = scaler_y.transform(y_test.reshape(-1, 1)).flatten()

# 转tensor
X_train_tensor = torch.FloatTensor(X_train_scaled)
y_train_tensor = torch.FloatTensor(y_train_scaled).reshape(-1, 1)
X_test_tensor = torch.FloatTensor(X_test_scaled)
y_test_tensor = torch.FloatTensor(y_test_scaled).reshape(-1, 1)

7.3.2 正向网络

class ForwardNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(4, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 1)
        )
    
    def forward(self, x):
        return self.net(x)

# 训练正向网络
forward_net = ForwardNet()
optimizer_f = optim.Adam(forward_net.parameters(), lr=0.001)
criterion = nn.MSELoss()

for epoch in range(300):
    optimizer_f.zero_grad()
    pred = forward_net(X_train_tensor)
    loss = criterion(pred, y_train_tensor)
    loss.backward()
    optimizer_f.step()
    
    if (epoch + 1) % 50 == 0:
        print(f'Forward Net Epoch {epoch+1}, Loss: {loss.item():.6f}')

7.3.3 逆网络

class InverseNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(1, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 4)
        )
    
    def forward(self, y):
        return self.net(y)

# 训练逆网络（串联）
inverse_net = InverseNet()
optimizer_i = optim.Adam(inverse_net.parameters(), lr=0.001)

for epoch in range(500):
    optimizer_i.zero_grad()
    
    # 逆网络预测参数
    X_pred = inverse_net(y_train_tensor)
    
    # 正向网络预测响应
    y_recon = forward_net(X_pred)
    
    # 重建损失
    loss = criterion(y_recon, y_train_tensor)
    
    loss.backward()
    optimizer_i.step()
    
    if (epoch + 1) % 50 == 0:
        print(f'Inverse Net Epoch {epoch+1}, Loss: {loss.item():.6f}')

7.3.4 测试逆设计

# 测试逆设计
target_freq = 2.5  # GHz
target_freq_scaled = scaler_y.transform([[target_freq]])
target_tensor = torch.FloatTensor(target_freq_scaled)

inverse_net.eval()
forward_net.eval()
with torch.no_grad():
    designed_params_scaled = inverse_net(target_tensor).numpy()
    designed_params = scaler_X.inverse_transform(designed_params_scaled)
    
    # 验证
    predicted_freq_scaled = forward_net(
        torch.FloatTensor(designed_params_scaled)
    ).numpy()
    predicted_freq = scaler_y.inverse_transform(predicted_freq_scaled)

print(f"目标频率: {target_freq:.3f} GHz")
print(f"设计参数: L={designed_params[0,0]:.2f}mm, W={designed_params[0,1]:.2f}mm, " +
      f"h={designed_params[0,2]:.2f}mm, εr={designed_params[0,3]:.2f}")
print(f"预测频率: {predicted_freq[0,0]:.3f} GHz")
print(f"误差: {abs(predicted_freq[0,0] - target_freq):.3f} GHz")

7.4 案例3：VAE生成天线拓扑

7.4.1 数据集

# 生成简化的天线拓扑数据（二值图像）
def generate_antenna_topologies(n_samples=1000, size=32):
    """生成简化的天线拓扑数据集"""
    images = []
    
    for _ in range(n_samples):
        img = np.zeros((size, size))
        
        # 随机生成矩形贴片
        cx, cy = size // 2, size // 2
        w = np.random.randint(8, 20)
        h = np.random.randint(6, 16)
        
        x1, x2 = cx - w//2, cx + w//2
        y1, y2 = cy - h//2, cy + h//2
        
        img[y1:y2, x1:x2] = 1.0
        
        # 添加馈线
        feed_w = np.random.randint(2, 4)
        img[y2:y2+5, cx-feed_w//2:cx+feed_w//2] = 1.0
        
        images.append(img)
    
    return np.array(images).reshape(-1, 1, size, size)

# 生成数据
topologies = generate_antenna_topologies(2000, 32)

# 划分数据集
train_size = int(0.8 * len(topologies))
X_train_topo = torch.FloatTensor(topologies[:train_size])
X_test_topo = torch.FloatTensor(topologies[train_size:])

7.4.2 VAE模型

class VAE(nn.Module):
    def __init__(self, input_channels=1, latent_dim=16, img_size=32):
        super().__init__()
        
        self.latent_dim = latent_dim
        self.img_size = img_size
        
        # 编码器
        self.encoder = nn.Sequential(
            nn.Conv2d(input_channels, 32, 4, 2, 1),  # 16x16
            nn.ReLU(),
            nn.Conv2d(32, 64, 4, 2, 1),  # 8x8
            nn.ReLU(),
            nn.Conv2d(64, 128, 4, 2, 1),  # 4x4
            nn.ReLU(),
        )
        
        self.fc_mu = nn.Linear(128 * 4 * 4, latent_dim)
        self.fc_logvar = nn.Linear(128 * 4 * 4, latent_dim)
        
        # 解码器
        self.fc_decode = nn.Linear(latent_dim, 128 * 4 * 4)
        
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(128, 64, 4, 2, 1),  # 8x8
            nn.ReLU(),
            nn.ConvTranspose2d(64, 32, 4, 2, 1),  # 16x16
            nn.ReLU(),
            nn.ConvTranspose2d(32, input_channels, 4, 2, 1),  # 32x32
            nn.Sigmoid()
        )
    
    def encode(self, x):
        h = self.encoder(x)
        h = h.view(h.size(0), -1)
        mu = self.fc_mu(h)
        logvar = self.fc_logvar(h)
        return mu, logvar
    
    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5 * logvar)
        eps = torch.randn_like(std)
        return mu + eps * std
    
    def decode(self, z):
        h = self.fc_decode(z)
        h = h.view(h.size(0), 128, 4, 4)
        return self.decoder(h)
    
    def forward(self, x):
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        recon = self.decode(z)
        return recon, mu, logvar

# 损失函数
def vae_loss(recon_x, x, mu, logvar):
    BCE = nn.functional.binary_cross_entropy(recon_x, x, reduction='sum')
    KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
    return BCE + 0.001 * KLD

# 训练
vae = VAE()
optimizer_vae = optim.Adam(vae.parameters(), lr=0.001)

batch_size = 64
train_loader = DataLoader(X_train_topo, batch_size=batch_size, shuffle=True)

for epoch in range(100):
    total_loss = 0
    for batch in train_loader:
        optimizer_vae.zero_grad()
        
        recon, mu, logvar = vae(batch)
        loss = vae_loss(recon, batch, mu, logvar)
        
        loss.backward()
        optimizer_vae.step()
        
        total_loss += loss.item()
    
    if (epoch + 1) % 20 == 0:
        print(f'Epoch {epoch+1}, Loss: {total_loss/len(X_train_topo):.4f}')

7.4.3 生成新拓扑

# 从潜在空间采样生成新拓扑
vae.eval()
with torch.no_grad():
    # 随机采样
    z = torch.randn(16, 16)
    generated = vae.decode(z)

# 可视化
fig, axes = plt.subplots(4, 4, figsize=(10, 10))
for i, ax in enumerate(axes.flat):
    ax.imshow(generated[i, 0], cmap='gray')
    ax.axis('off')
plt.suptitle('Generated Antenna Topologies')
plt.tight_layout()
plt.savefig('generated_topologies.png', dpi=150)
plt.close()

---

总结与展望

8.1 本章总结

本章系统介绍了机器学习在电磁设计中的应用：

神经网络代理模型

• 用神经网络替代耗时的电磁仿真
• 实现100-10000倍加速
• 保持高精度预测

数据驱动优化

• 结合代理模型和进化算法
• 大幅减少精确仿真次数
• 支持多目标优化

深度学习逆设计

• 从目标响应直接预测结构
• 避免迭代优化
• 实现实时设计

生成模型应用

• 生成新颖的电磁结构
• 探索设计空间
• 发现非直观解

8.2 关键要点

1. 数据质量至关重要

   • 充分覆盖设计空间
   • 准确的标签数据
   • 适当的预处理

2. 模型选择需权衡

   • 精度 vs 速度
   • 复杂度 vs 可解释性
   • 训练成本 vs 推理成本

3. 物理约束的融入

   • 物理信息神经网络（PINN）
   • 约束优化
   • 后处理修正

8.3 未来发展方向

技术趋势

1. 大模型与预训练

   • 通用电磁设计基础模型
   • 迁移学习
   • 少样本学习

2. 多模态融合

   • 结合几何、材料、性能
   • 文本描述生成设计
   • 多物理场耦合

3. 自动化设计流程

   • 端到端自动化
   • 自主实验
   • 闭环优化

应用拓展

• 6G通信器件
• 量子计算元件
• 生物医学设备
• 可重构智能表面

8.4 实践建议

入门路径

1. 从简单的回归问题开始
2. 使用现有数据集练习
3. 逐步尝试更复杂的架构
4. 结合实际电磁仿真验证

工具推荐

• 深度学习框架：PyTorch, TensorFlow
• 电磁仿真：CST, HFSS, COMSOL
• 数据处理：NumPy, Pandas, Scikit-learn
• 可视化：Matplotlib, TensorBoard

机器学习正在深刻改变电磁设计范式，掌握这些技术将使工程师能够更高效地解决复杂设计问题，加速创新进程。

---

参考文献

1. Goodfellow I, Bengio Y, Courville A. Deep Learning. MIT Press, 2016.
2. Liu D, Tan Y, Khoram E, et al. Training deep neural networks for the inverse design of nanophotonic structures. ACS Photonics, 2018.
3. Ma W, Cheng F, Xu Y, et al. Probabilistic representation and inverse design of metamaterials based on a deep generative model with semi-supervised learning strategy. Advanced Materials, 2019.
4. An S, Bower J, Liu B, et al. A deep learning approach for objective-driven all-dielectric metasurface design. ACS Photonics, 2019.
5. Qiu J, Tang S, Ma C, et al. Artificial neural network approach for inverse design of patch antenna. IEEE Access, 2019.