583 lines
26 KiB
Python
583 lines
26 KiB
Python
"""
|
||
Parametric (multivariate) orthonormal vector fitting for geometry + frequency.
|
||
|
||
根据论文: Robust Parametric Macromodeling Using Multivariate Orthonormal Vector Fitting
|
||
|
||
核心思想 (简化实现版本):
|
||
1. 在频域上使用一组全局极点 a_k, 通过所有参数样本共享。
|
||
2. 对每个几何样本 s (由 (W,L) 给出) 与端口对 (i,j) 构建线性最小二乘问题, 固定极点估计该样本的残值 r_{k,s}, 以及常数/斜率项 d_s, e_s。
|
||
3. 将随几何参数变化的残值/常数/斜率在一个离散正交 (QR) 的多元多项式基 Φ_q(W,L) 上展开: r_k(W,L) ≈ Σ_q c_{k,q} Φ_q(W,L)。
|
||
4. 评价阶段: 先用 (W,L) 计算 Φ(W,L), 再恢复 r_k,d,e, 组合成有理函数 Σ_k r_k/(p-a_k)+d+p e。
|
||
|
||
该文件实现一个最小可用版本, 方便后续扩展(极点迭代 / 被动性约束 / 模型压缩等)。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from dataclasses import dataclass
|
||
from typing import List, Tuple, Dict, Any, Optional
|
||
import numpy as np
|
||
from skrf import Network
|
||
import skrf as rf
|
||
from models.capa import Capa
|
||
from models.basic import ModelBasicDatasetUnit
|
||
import warnings
|
||
|
||
|
||
@dataclass
|
||
class ParametricVFConfig:
|
||
# 有理函数项数量 (K 个极点)
|
||
n_poles: int = 8
|
||
# 参数多项式最大总次数 (a+b <= degree)
|
||
param_total_degree: int = 3
|
||
# 频率单位: Hz (Network 中 f 默认 Hz)
|
||
damping: float = 0.02 # 极点实部相对于 2π f_max 的比例, 保证稳定
|
||
# 最大保留频率点 (特征频率抽样); None 表示不裁剪
|
||
max_freq_points: Optional[int] = None
|
||
# 频率选择方法: 'curvature' 或 'uniform'
|
||
freq_selection_method: str = 'curvature'
|
||
# 曲率阈值(可选), 仅 method='curvature' 时生效
|
||
curvature_threshold: Optional[float] = None
|
||
# VF 极点迭代次数 (0 表示不迭代)
|
||
vf_iterations: int = 0
|
||
# 极点迭代时是否打印警告
|
||
verbose: bool = True
|
||
# 未来可添加: 加权, 正则, 被动性投影等
|
||
|
||
|
||
def generate_monomial_exponents(dim: int, total_degree: int) -> List[Tuple[int, ...]]:
|
||
"""生成所有满足指数和 <= total_degree 的多元单项式指数。
|
||
对于 2 维 (W,L) 返回 (a,b) 列表。
|
||
"""
|
||
exps: List[Tuple[int, ...]] = []
|
||
def rec(prefix: Tuple[int, ...], remaining_dim: int, max_sum: int):
|
||
if remaining_dim == 1:
|
||
for i in range(max_sum + 1):
|
||
exps.append(prefix + (i,))
|
||
return
|
||
for i in range(max_sum + 1):
|
||
rec(prefix + (i,), remaining_dim - 1, max_sum - i)
|
||
rec(tuple(), dim, total_degree)
|
||
return exps
|
||
|
||
|
||
class OrthonormalParamBasis:
|
||
"""离散点集上 (W,L) 的多项式基 QR 正交化封装。"""
|
||
def __init__(self, W: np.ndarray, L: np.ndarray, total_degree: int):
|
||
assert W.shape == L.shape
|
||
self.W_mean = W.mean()
|
||
self.W_std = W.std() or 1.0
|
||
self.L_mean = L.mean()
|
||
self.L_std = L.std() or 1.0
|
||
self.exps = generate_monomial_exponents(2, total_degree)
|
||
# 构建单项式矩阵 M (Ns x M)
|
||
M = []
|
||
Wn = (W - self.W_mean) / self.W_std
|
||
Ln = (L - self.L_mean) / self.L_std
|
||
for a, b in self.exps:
|
||
M.append((Wn ** a) * (Ln ** b))
|
||
M = np.stack(M, axis=1) # (Ns, M)
|
||
# QR 分解获得离散正交基 Q, R 上三角
|
||
Q, R = np.linalg.qr(M)
|
||
self.Q = Q # (Ns, Q)
|
||
self.R = R # (Q, Q)
|
||
self.R_inv = np.linalg.inv(R)
|
||
|
||
@property
|
||
def n_basis(self) -> int:
|
||
return self.Q.shape[1]
|
||
|
||
def phi_matrix(self) -> np.ndarray:
|
||
return self.Q # 对应样本点的基函数值
|
||
|
||
def eval(self, W: float, L: float) -> np.ndarray:
|
||
Wn = (W - self.W_mean) / self.W_std
|
||
Ln = (L - self.L_mean) / self.L_std
|
||
monomials = []
|
||
for a, b in self.exps:
|
||
monomials.append((Wn ** a) * (Ln ** b))
|
||
m = np.asarray(monomials) # (M,)
|
||
# M = Q R => 对新点 m = phi R => phi = m R^{-1}
|
||
phi = m @ self.R_inv
|
||
return phi # (Q,)
|
||
|
||
|
||
class ParametricVectorFitting:
|
||
"""多参数 (W,L) 二端口/多端口 S 参数的简化 Parametric VF。
|
||
|
||
模型形式 (单个端口对):
|
||
H(p; μ) ≈ Σ_{k=1..K} r_k(μ)/(p - a_k) + d(μ) + p e(μ)
|
||
其中 μ = (W,L)。r_k, d, e 在参数域被正交基展开。
|
||
"""
|
||
def __init__(self, config: ParametricVFConfig):
|
||
self.cfg = config
|
||
self.frequencies: np.ndarray | None = None # (Nf,)
|
||
self.poles: np.ndarray | None = None # (K,)
|
||
self.basis: OrthonormalParamBasis | None = None
|
||
# 残值系数: (nports, nports, K, Q)
|
||
self.residue_coeffs: np.ndarray | None = None
|
||
# d,e 系数: (nports, nports, Q)
|
||
self.d_coeffs: np.ndarray | None = None
|
||
self.e_coeffs: np.ndarray | None = None
|
||
self.meta: Dict[str, Any] = {}
|
||
|
||
def _init_global_poles(self, freqs: np.ndarray) -> np.ndarray:
|
||
f_min, f_max = freqs.min(), freqs.max()
|
||
# 使用对数均匀分布 (排除 0) + 负实部保证稳定
|
||
f_samples = np.logspace(np.log10(max(f_min, freqs[1] if len(freqs) > 1 else f_min*1.1)), np.log10(f_max), self.cfg.n_poles)
|
||
# 极点: -σ + j 2π f_k
|
||
sigma = self.cfg.damping * 2 * np.pi * f_max
|
||
poles = -sigma + 1j * 2 * np.pi * f_samples
|
||
return poles
|
||
|
||
# ----------------- 内部工具函数 (前置以便类型检查) -----------------
|
||
def _build_frequency_matrix(self, p_vec: np.ndarray, poles: np.ndarray) -> np.ndarray:
|
||
K = len(poles)
|
||
F_base = np.zeros((len(p_vec), K + 2), dtype=complex)
|
||
for k, a_k in enumerate(poles):
|
||
F_base[:, k] = 1.0 / (p_vec - a_k)
|
||
F_base[:, K] = 1.0
|
||
F_base[:, K + 1] = p_vec
|
||
return F_base
|
||
|
||
def _solve_residues_given_poles(self, aligned_S: List[np.ndarray], p_vec: np.ndarray):
|
||
assert self.poles is not None, "Poles not initialized"
|
||
nports = aligned_S[0].shape[1]
|
||
Ns = len(aligned_S)
|
||
K = len(self.poles)
|
||
residues_samples = np.zeros((nports, nports, K, Ns), dtype=complex)
|
||
d_samples = np.zeros((nports, nports, Ns), dtype=complex)
|
||
e_samples = np.zeros((nports, nports, Ns), dtype=complex)
|
||
F_base = self._build_frequency_matrix(p_vec, self.poles)
|
||
for s_idx, Sdata in enumerate(aligned_S):
|
||
for i in range(nports):
|
||
for j in range(nports):
|
||
y = Sdata[:, i, j]
|
||
x, *_ = np.linalg.lstsq(F_base, y, rcond=None)
|
||
residues_samples[i, j, :, s_idx] = x[:K]
|
||
d_samples[i, j, s_idx] = x[K]
|
||
e_samples[i, j, s_idx] = x[K+1]
|
||
return residues_samples, d_samples, e_samples
|
||
|
||
def _select_characteristic_freqs(self, freqs: np.ndarray, S_list: List[np.ndarray], max_points: int,
|
||
method: str = 'curvature', threshold: Optional[float] = None) -> np.ndarray:
|
||
Nf = len(freqs)
|
||
if max_points >= Nf:
|
||
return np.arange(Nf)
|
||
if method == 'uniform':
|
||
idx = np.linspace(0, Nf-1, max_points, dtype=int)
|
||
return np.unique(idx)
|
||
mags = []
|
||
for S in S_list:
|
||
mags.append(np.mean(np.abs(S), axis=(1,2))) # (Nf,)
|
||
agg = np.mean(np.stack(mags, axis=1), axis=1) # (Nf,)
|
||
curv = np.zeros_like(agg)
|
||
curv[1:-1] = np.abs(agg[2:] - 2*agg[1:-1] + agg[:-2])
|
||
base = {0, Nf-1}
|
||
if threshold is not None:
|
||
cand = np.where(curv >= threshold)[0]
|
||
else:
|
||
order = np.argsort(-curv)
|
||
cand = order
|
||
selected = list(base)
|
||
for idx in cand:
|
||
if idx in base:
|
||
continue
|
||
selected.append(idx)
|
||
if len(selected) >= max_points:
|
||
break
|
||
return np.array(sorted(selected))
|
||
|
||
def _vf_iterate_poles(self, aligned_S: List[np.ndarray], p_vec: np.ndarray,
|
||
residues_samples: np.ndarray, d_samples: np.ndarray, e_samples: np.ndarray) -> np.ndarray:
|
||
assert self.poles is not None, "Poles not initialized"
|
||
nports = residues_samples.shape[0]
|
||
K = len(self.poles)
|
||
Ns = len(aligned_S)
|
||
Nf = len(p_vec)
|
||
n_pairs = nports * nports
|
||
n_r = n_pairs * K
|
||
n_c = K
|
||
n_d = n_pairs
|
||
n_e = n_pairs
|
||
total_unknowns = n_r + n_c + n_d + n_e
|
||
rows = Ns * Nf * n_pairs
|
||
A = np.zeros((rows, total_unknowns), dtype=complex)
|
||
b = np.zeros(rows, dtype=complex)
|
||
def pair_index(i,j):
|
||
return i*nports + j
|
||
row = 0
|
||
for s_idx, Sdata in enumerate(aligned_S):
|
||
for f_idx, p in enumerate(p_vec):
|
||
denom = p - self.poles
|
||
basis_freq = 1.0/denom
|
||
for i in range(nports):
|
||
for j in range(nports):
|
||
H = Sdata[f_idx, i, j]
|
||
b[row] = H
|
||
pair = pair_index(i,j)
|
||
r_offset = pair*K
|
||
A[row, r_offset:r_offset+K] = basis_freq
|
||
A[row, n_r:n_r+K] = -H * basis_freq
|
||
A[row, n_r + n_c + pair] = 1.0
|
||
A[row, n_r + n_c + n_d + pair] = p
|
||
row += 1
|
||
x, *_ = np.linalg.lstsq(A, b, rcond=None)
|
||
c_k = x[n_r:n_r+n_c]
|
||
poly_total = np.poly(self.poles)
|
||
acc = poly_total.copy()
|
||
for k in range(K):
|
||
others = [self.poles[m] for m in range(K) if m != k]
|
||
term = c_k[k] * np.poly(others)
|
||
acc = np.polyadd(acc, term)
|
||
new_poles = np.roots(acc)
|
||
return new_poles
|
||
|
||
def fit(self, dataset: List[ModelBasicDatasetUnit], network_loader=Capa.network):
|
||
# 载入所有 Network
|
||
networks: List[Network] = []
|
||
W_list, L_list = [], []
|
||
for unit in dataset:
|
||
net = network_loader(unit.result_dir, unit.id)
|
||
networks.append(net)
|
||
W_list.append(unit.parameters["W"])
|
||
L_list.append(unit.parameters["L"])
|
||
assert len(networks) > 0, "Empty dataset"
|
||
# 处理不同频率点数量: 取公共重叠频段并插值到统一网格
|
||
freqs_list = [n.f for n in networks]
|
||
f_start = max(f[0] for f in freqs_list)
|
||
f_stop = min(f[-1] for f in freqs_list)
|
||
if f_stop <= f_start:
|
||
raise ValueError("No overlapping frequency range among networks")
|
||
# 选择基准网格: 使用第一个网络在重叠区间内的频点, 若其它网络缺该点则插值
|
||
base_freqs = networks[0].f
|
||
mask = (base_freqs >= f_start) & (base_freqs <= f_stop)
|
||
freqs = base_freqs[mask]
|
||
# 如果其它网络点数差异较大, 可选: 统一稠密度 (这里只在差异>5%时使用最小长度网格)
|
||
for f in freqs_list[1:]:
|
||
# 判断差异比例
|
||
if abs(len(f) - len(freqs)) / max(len(freqs),1) > 0.2:
|
||
# 使用所有网络在重叠区间内最少点数, 构造等间距网格
|
||
n_common = min(len(ff[(ff>=f_start)&(ff<=f_stop)]) for ff in freqs_list)
|
||
freqs = np.linspace(f_start, f_stop, n_common)
|
||
warnings.warn("Frequency grids differ significantly; using uniform linspace for interpolation.")
|
||
break
|
||
# 对每个网络插值到 freqs (实部/虚部分开线性插值)
|
||
aligned_S = [] # List[(Nf, nports, nports)]
|
||
for net in networks:
|
||
f_src = net.f
|
||
# 获取在目标范围内原始数据 (若后面改用插值网格不同于原点, 仍需完整插值)
|
||
S_src = net.s # (Nf_src, nports, nports)
|
||
nports = net.nports
|
||
if not np.array_equal(f_src, freqs):
|
||
# 线性插值 (对每个端口对实部与虚部)
|
||
S_interp = np.zeros((len(freqs), nports, nports), dtype=complex)
|
||
for i in range(nports):
|
||
for j in range(nports):
|
||
y = S_src[:, i, j]
|
||
# numpy.interp 需要单调递增; 为类型检查器显式转为 np.ndarray
|
||
y_arr = np.asarray(y)
|
||
y_real = np.real(y_arr)
|
||
y_imag = np.imag(y_arr)
|
||
real_part = np.interp(freqs, f_src, y_real)
|
||
imag_part = np.interp(freqs, f_src, y_imag)
|
||
S_interp[:, i, j] = real_part + 1j * imag_part
|
||
aligned_S.append(S_interp)
|
||
else:
|
||
aligned_S.append(S_src[mask] if len(S_src)==len(base_freqs) and mask.sum()!=len(base_freqs) else S_src)
|
||
self.frequencies = freqs
|
||
nports = networks[0].nports
|
||
Ns = len(networks)
|
||
# 参数正交基
|
||
self.basis = OrthonormalParamBasis(np.array(W_list), np.array(L_list), self.cfg.param_total_degree)
|
||
Phi = self.basis.phi_matrix() # (Ns, Q)
|
||
Qn = Phi.shape[1]
|
||
# (可选) 特征频率子采样
|
||
if self.cfg.max_freq_points is not None and len(freqs) > self.cfg.max_freq_points:
|
||
sel_idx = self._select_characteristic_freqs(freqs, aligned_S, self.cfg.max_freq_points,
|
||
method=self.cfg.freq_selection_method,
|
||
threshold=self.cfg.curvature_threshold)
|
||
freqs = freqs[sel_idx]
|
||
aligned_S = [S[sel_idx, :, :] for S in aligned_S]
|
||
if self.cfg.verbose:
|
||
warnings.warn(f"Frequency reduced to {len(freqs)} points (method={self.cfg.freq_selection_method}).")
|
||
# 初始化极点
|
||
self.poles = self._init_global_poles(freqs)
|
||
p_vec = 1j * 2 * np.pi * freqs
|
||
# 首次求解残值
|
||
residues_samples, d_samples, e_samples = self._solve_residues_given_poles(aligned_S, p_vec)
|
||
# 极点迭代 (简化共享极点 VF)
|
||
if self.cfg.vf_iterations > 0:
|
||
for it in range(self.cfg.vf_iterations):
|
||
new_poles = self._vf_iterate_poles(aligned_S, p_vec, residues_samples, d_samples, e_samples)
|
||
# 反射不稳定极点
|
||
new_poles = np.array([p if p.real < 0 else complex(-p.real, p.imag) for p in new_poles])
|
||
# 去重: 近似重复 (距离 < 1e-3 * |p|) 过滤
|
||
filtered = []
|
||
for p in new_poles:
|
||
if all(abs(p - q) > 1e-3*max(1.0, abs(p)) for q in filtered):
|
||
filtered.append(p)
|
||
if self.cfg.verbose:
|
||
print(f"[VF-Iter {it+1}] poles -> {len(filtered)} kept")
|
||
self.poles = np.array(filtered, dtype=complex)
|
||
p_vec = 1j * 2 * np.pi * freqs
|
||
residues_samples, d_samples, e_samples = self._solve_residues_given_poles(aligned_S, p_vec)
|
||
# 在参数基上再拟合: 由于 Phi 正交, 系数 = Phi^H * values
|
||
PhiH = Phi.conj().T # (Q, Ns)
|
||
K = self.poles.shape[0]
|
||
self.residue_coeffs = np.zeros((nports, nports, K, Qn), dtype=complex)
|
||
self.d_coeffs = np.zeros((nports, nports, Qn), dtype=complex)
|
||
self.e_coeffs = np.zeros((nports, nports, Qn), dtype=complex)
|
||
for i in range(nports):
|
||
for j in range(nports):
|
||
for k in range(K):
|
||
vk = residues_samples[i, j, k, :] # (Ns,)
|
||
self.residue_coeffs[i, j, k, :] = PhiH @ vk
|
||
self.d_coeffs[i, j, :] = PhiH @ d_samples[i, j, :]
|
||
self.e_coeffs[i, j, :] = PhiH @ e_samples[i, j, :]
|
||
# 简单误差评估 (训练点重建 RMS)
|
||
F_base = self._build_frequency_matrix(p_vec, self.poles)
|
||
train_rms = self._compute_training_rms(residues_samples, d_samples, e_samples, F_base, aligned_S)
|
||
self.meta['train_rms'] = train_rms
|
||
self.meta['nports'] = nports
|
||
self.meta['Ns'] = Ns
|
||
self.meta['Q'] = Qn
|
||
return self
|
||
|
||
def _compute_training_rms(self, residues_samples, d_samples, e_samples, F_base, original_S_list):
|
||
"""计算每个样本的平均端口对 RMS 误差。"""
|
||
nports = residues_samples.shape[0]
|
||
K = residues_samples.shape[2]
|
||
Ns = residues_samples.shape[3]
|
||
Nf = F_base.shape[0]
|
||
rms = []
|
||
for s in range(Ns):
|
||
err_sq_sum = 0.0
|
||
count = 0
|
||
S_ref = original_S_list[s]
|
||
for i in range(nports):
|
||
for j in range(nports):
|
||
x = np.concatenate([
|
||
residues_samples[i, j, :, s],
|
||
[d_samples[i, j, s], e_samples[i, j, s]]
|
||
]) # (K+2,)
|
||
y_hat = F_base @ x # (Nf,)
|
||
y_ref = S_ref[:, i, j]
|
||
err = y_ref - y_hat
|
||
err_sq_sum += np.mean(np.abs(err)**2)
|
||
count += 1
|
||
rms.append(np.sqrt(err_sq_sum / max(count,1)))
|
||
return rms
|
||
|
||
def evaluate(self, W: float, L: float, freqs: np.ndarray | None = None) -> np.ndarray:
|
||
"""返回插值后的 S 参数 (Nf, nports, nports)。"""
|
||
assert self.frequencies is not None and self.poles is not None
|
||
assert self.basis is not None
|
||
assert self.residue_coeffs is not None and self.d_coeffs is not None and self.e_coeffs is not None, "Model not fitted"
|
||
if freqs is None:
|
||
freqs = self.frequencies
|
||
# 若请求频率网格不同, 需要重建频率矩阵
|
||
p_vec = 1j * 2 * np.pi * freqs
|
||
K = len(self.poles)
|
||
nports = self.residue_coeffs.shape[0]
|
||
phi = self.basis.eval(W, L) # (Q,)
|
||
# 预分配
|
||
S_eval = np.zeros((len(freqs), nports, nports), dtype=complex)
|
||
denom_cache = np.zeros((len(freqs), K), dtype=complex)
|
||
for k, a_k in enumerate(self.poles):
|
||
denom_cache[:, k] = 1.0 / (p_vec - a_k)
|
||
for i in range(nports):
|
||
for j in range(nports):
|
||
# 恢复参数依赖的残值/常数/斜率
|
||
r_k = (self.residue_coeffs[i, j, :, :] @ phi) # (K,)
|
||
d = self.d_coeffs[i, j, :] @ phi
|
||
e = self.e_coeffs[i, j, :] @ phi
|
||
Hf = denom_cache @ r_k + d + p_vec * e # (Nf,)
|
||
S_eval[:, i, j] = Hf
|
||
return S_eval
|
||
|
||
def export_s2p(self, W: float, L: float, filepath: str, freqs: np.ndarray | None = None, z0: float | complex = 50) -> str:
|
||
"""在给定几何参数 (W,L) 下计算 S 并写入 Touchstone (.sNp) 文件。
|
||
|
||
参数:
|
||
W, L: 几何参数
|
||
filepath: 目标文件完整路径, 可包含或不包含 .s2p/.sNp 后缀
|
||
freqs: 可选自定义频率数组 (需在训练频率范围内); 默认使用训练频率
|
||
z0: 端口参考阻抗 (标量或与端口数相同长度可扩展)
|
||
|
||
返回:
|
||
实际写入的文件路径
|
||
"""
|
||
assert self.frequencies is not None, "Model not fitted"
|
||
S_eval = self.evaluate(W, L, freqs)
|
||
if freqs is None:
|
||
freqs = self.frequencies
|
||
nports = S_eval.shape[1]
|
||
freqs_arr = np.asarray(freqs)
|
||
# 构建 Network 对象
|
||
ntw = rf.Network(f=freqs_arr, s=S_eval, z0=z0)
|
||
# 解析输出路径
|
||
import os
|
||
base_dir = os.path.dirname(filepath) or '.'
|
||
os.makedirs(base_dir, exist_ok=True)
|
||
base_name = os.path.basename(filepath)
|
||
# 去掉可能已有的扩展名, 由 skrf 自动加 .sNp
|
||
if '.' in base_name:
|
||
base_name = '.'.join(base_name.split('.')[:-1]) or base_name
|
||
# 写文件
|
||
ntw.write_touchstone(base_name, dir=base_dir)
|
||
# 构造最终文件名 (.sNp)
|
||
final_path = os.path.join(base_dir, f"{base_name}.s{nports}p")
|
||
return final_path
|
||
|
||
def to_dict(self) -> Dict[str, Any]:
|
||
return {
|
||
'config': self.cfg.__dict__,
|
||
'frequencies': self.frequencies.tolist() if self.frequencies is not None else None,
|
||
'poles': self.poles.tolist() if self.poles is not None else None,
|
||
'basis': {
|
||
'W_mean': getattr(self.basis, 'W_mean', None),
|
||
'W_std': getattr(self.basis, 'W_std', None),
|
||
'L_mean': getattr(self.basis, 'L_mean', None),
|
||
'L_std': getattr(self.basis, 'L_std', None),
|
||
'exps': getattr(self.basis, 'exps', None),
|
||
'R': (lambda _R: _R.tolist() if _R is not None else None)(getattr(self.basis, 'R', None)),
|
||
},
|
||
'residue_coeffs': self.residue_coeffs.tolist() if self.residue_coeffs is not None else None,
|
||
'd_coeffs': self.d_coeffs.tolist() if self.d_coeffs is not None else None,
|
||
'e_coeffs': self.e_coeffs.tolist() if self.e_coeffs is not None else None,
|
||
'meta': self.meta,
|
||
}
|
||
|
||
@staticmethod
|
||
def from_dict(data: Dict[str, Any]) -> 'ParametricVectorFitting':
|
||
cfg = ParametricVFConfig(**data['config'])
|
||
obj = ParametricVectorFitting(cfg)
|
||
obj.frequencies = np.array(data['frequencies']) if data['frequencies'] is not None else None
|
||
obj.poles = np.array(data['poles']) if data['poles'] is not None else None
|
||
# 重建 basis (仅用于 eval); 重新构造 R_inv
|
||
if data.get('basis') and data['basis']['R'] is not None:
|
||
basis_stub = OrthonormalParamBasis(np.array([0.0, 1.0]), np.array([0.0, 1.0]), 1) # 占位
|
||
basis_stub.W_mean = data['basis']['W_mean']
|
||
basis_stub.W_std = data['basis']['W_std']
|
||
basis_stub.L_mean = data['basis']['L_mean']
|
||
basis_stub.L_std = data['basis']['L_std']
|
||
basis_stub.exps = [tuple(e) for e in data['basis']['exps']]
|
||
R = np.array(data['basis']['R'])
|
||
basis_stub.R = R
|
||
basis_stub.R_inv = np.linalg.inv(R)
|
||
# Q 不需要 (仅用于训练点), 设为 None
|
||
basis_stub.Q = None # type: ignore
|
||
obj.basis = basis_stub
|
||
if data.get('residue_coeffs') is not None:
|
||
obj.residue_coeffs = np.array(data['residue_coeffs'])
|
||
if data.get('d_coeffs') is not None:
|
||
obj.d_coeffs = np.array(data['d_coeffs'])
|
||
if data.get('e_coeffs') is not None:
|
||
obj.e_coeffs = np.array(data['e_coeffs'])
|
||
obj.meta = data.get('meta', {})
|
||
return obj
|
||
|
||
# 划分
|
||
def split_dataset(dataset: List[ModelBasicDatasetUnit], train_ratio: float = 0.7, shuffle: bool = True, seed: int = 0) -> Tuple[List[ModelBasicDatasetUnit], List[ModelBasicDatasetUnit]]:
|
||
"""划分数据集 70% 训练 / 30% 测试 (默认可改)。"""
|
||
ds = list(dataset)
|
||
if shuffle:
|
||
rng = np.random.default_rng(seed)
|
||
rng.shuffle(ds)
|
||
n_train = int(len(ds) * train_ratio)
|
||
return ds[:n_train], ds[n_train:]
|
||
|
||
|
||
def _interp_s_to_freqs(S: np.ndarray, f_src: np.ndarray, f_tgt: np.ndarray) -> np.ndarray:
|
||
"""将 S(f_src) 线性插值到 f_tgt (复数分离实虚部)。"""
|
||
if np.array_equal(f_src, f_tgt):
|
||
return S
|
||
nports = S.shape[1]
|
||
S_new = np.zeros((len(f_tgt), nports, nports), dtype=complex)
|
||
for i in range(nports):
|
||
for j in range(nports):
|
||
y = S[:, i, j]
|
||
real_part = np.interp(f_tgt, f_src, np.real(y))
|
||
imag_part = np.interp(f_tgt, f_src, np.imag(y))
|
||
S_new[:, i, j] = real_part + 1j * imag_part
|
||
return S_new
|
||
|
||
|
||
def evaluate_dataset(model: ParametricVectorFitting,
|
||
subset: List[ModelBasicDatasetUnit],
|
||
network_loader=Capa.network) -> Dict[str, Any]:
|
||
"""对一个子集评估拟合质量，输出每样本与整体统计."""
|
||
assert model.frequencies is not None
|
||
freqs = model.frequencies
|
||
results = []
|
||
mag_err_db_all = []
|
||
rms_all = []
|
||
for unit in subset:
|
||
net = network_loader(unit.result_dir, unit.id)
|
||
S_ref = _interp_s_to_freqs(net.s, net.f, freqs) # (Nf, nports, nports)
|
||
S_pred = model.evaluate(unit.parameters["W"], unit.parameters["L"], freqs)
|
||
err = S_pred - S_ref
|
||
rms = float(np.sqrt(np.mean(np.abs(err)**2)))
|
||
# 幅度 dB 误差
|
||
mag_ref_db = 20*np.log10(np.clip(np.abs(S_ref), 1e-15, None))
|
||
mag_pred_db = 20*np.log10(np.clip(np.abs(S_pred), 1e-15, None))
|
||
mag_err_db = float(np.mean(np.abs(mag_pred_db - mag_ref_db)))
|
||
rms_all.append(rms)
|
||
mag_err_db_all.append(mag_err_db)
|
||
results.append({
|
||
'id': unit.id,
|
||
'W': unit.parameters['W'],
|
||
'L': unit.parameters['L'],
|
||
'rms': rms,
|
||
'mag_err_db': mag_err_db
|
||
})
|
||
summary = {
|
||
'count': len(subset),
|
||
'rms_mean': float(np.mean(rms_all)) if rms_all else None,
|
||
'rms_max': float(np.max(rms_all)) if rms_all else None,
|
||
'mag_err_db_mean': float(np.mean(mag_err_db_all)) if mag_err_db_all else None,
|
||
'mag_err_db_max': float(np.max(mag_err_db_all)) if mag_err_db_all else None,
|
||
'details': results
|
||
}
|
||
return summary
|
||
|
||
|
||
# 简要使用示例 (非执行):
|
||
if __name__ == "__main__":
|
||
|
||
capa = Capa()
|
||
capa.sweep()
|
||
print("sweep finished")
|
||
capa.export('capa_results.json')
|
||
capa.clear()
|
||
capa.load('capa_results.json')
|
||
dataset = capa.results
|
||
|
||
# 70% 训练 / 30% 测试
|
||
train_set, test_set = split_dataset(dataset, train_ratio=0.7, shuffle=True, seed=42)
|
||
print(f"Train: {len(train_set)} Test: {len(test_set)}")
|
||
|
||
cfg = ParametricVFConfig(n_poles=10, param_total_degree=3, vf_iterations=2,
|
||
max_freq_points=50)
|
||
pvf = ParametricVectorFitting(cfg).fit(train_set)
|
||
|
||
train_metrics = evaluate_dataset(pvf, train_set)
|
||
test_metrics = evaluate_dataset(pvf, test_set)
|
||
|
||
pvf.meta['train_eval'] = train_metrics
|
||
pvf.meta['test_eval'] = test_metrics
|
||
|
||
def _print_metrics(title: str, m: Dict[str, Any]):
|
||
print(f"[{title}] samples={m['count']}"
|
||
f" RMS_mean={m['rms_mean']:.4e} RMS_max={m['rms_max']:.4e}"
|
||
f" |Δ|dB_mean={m['mag_err_db_mean']:.3f}dB |Δ|dB_max={m['mag_err_db_max']:.3f}dB")
|
||
|
||
_print_metrics("TRAIN", train_metrics)
|
||
_print_metrics("TEST", test_metrics)
|
||
|
||
# 示例：导出一个测试点的拟合结果为 s2p
|
||
if test_set:
|
||
sample = test_set[0]
|
||
out_path = pvf.export_s2p(sample.parameters["W"], sample.parameters["L"], filepath='outputs/pvf_test_sample')
|
||
print("Exported:", out_path) |