文章目录
-
- 摘要
- [1. 背景与意义](#1. 背景与意义)
-
- [1.1 研究背景](#1.1 研究背景)
-
- [1.1.1 6G愿景与ISAC的兴起](#1.1.1 6G愿景与ISAC的兴起)
- [1.1.2 ISAC面临的安全挑战](#1.1.2 ISAC面临的安全挑战)
- [1.1.3 智能反射面技术及其安全潜力](#1.1.3 智能反射面技术及其安全潜力)
- [1.1.4 现有研究现状与不足](#1.1.4 现有研究现状与不足)
- [1.2 研究意义](#1.2 研究意义)
- [2. 系统模型与问题表述](#2. 系统模型与问题表述)
-
- [2.1 发射信号](#2.1 发射信号)
- [2.2 信道与接收信号](#2.2 信道与接收信号)
- [2.3 性能指标与优化问题](#2.3 性能指标与优化问题)
- [3. 基于SCA的优化算法](#3. 基于SCA的优化算法)
-
- [3.1 核心思想概述](#3.1 核心思想概述)
- [3.2 目标函数的凸近似](#3.2 目标函数的凸近似)
- [3.3 SINR约束的凸化](#3.3 SINR约束的凸化)
- [3.4 信息泄漏约束的凸化](#3.4 信息泄漏约束的凸化)
- [3.5 恒模约束的处理](#3.5 恒模约束的处理)
- [3.6 最终SOCP子问题](#3.6 最终SOCP子问题)
- [3.7 初始可行点获取](#3.7 初始可行点获取)
- [3.8. 算法复杂度分析](#3.8. 算法复杂度分析)
- [3.9. 复现结果](#3.9. 复现结果)
- 仿真参数表
- [4. 结论](#4. 结论)
- 参考文献
摘要
通信感知一体化（Integrated Sensing and Communication, ISAC）作为第六代移动通信系统的核心技术之一，通过共享频谱与硬件资源实现了通信与雷达感知功能的融合。然而，感知信号的广播特性使得通信信息容易暴露于恶意目标，带来严峻的物理层安全挑战。智能反射面（Intelligent Reflecting Surface, RIS）以其独特的被动波束成形能力，为增强无线通信安全提供了新的技术路径。本文针对IRS辅助的保密ISAC系统，研究发射波束成形与IRS反射系数的联合优化问题，目标是在满足通信用户信干噪比约束与信息泄漏约束的前提下，最大化目标方向的波束图增益。由于该问题具有非凸性和变量高度耦合的特点，传统交替优化方法效率低下且解质量不佳。本文系统阐述了一种基于连续凸近似（Successive Convex Approximation, SCA）的优化方法，通过对目标函数和约束条件构造凸下界，将所有变量同步更新，并利用二阶锥规划（Second-Order Cone Programming, SOCP）进行高效求解，并并复现了主要实验。
1. 背景与意义
1.1 研究背景
1.1.1 6G愿景与ISAC的兴起
第五代移动通信系统（5G）已在全球范围内大规模部署，其核心愿景是"万物互联"，旨在实现人与人、人与物以及物与物之间的普遍连接。然而，随着自动驾驶、增强现实（AR）、虚拟现实（VR）、无人机巡检、智慧城市、环境监测等新兴业务的不断涌现，未来网络的需求已不再局限于单纯的数据传输。这些应用场景要求通信网络不仅具备连接能力，还需要拥有对物理世界的感知能力，例如目标的检测、定位、跟踪和成像等。
在此背景下，第六代移动通信系统（6G）将"万物智联、数字孪生"作为更高层次的发展目标，其中**集成感知与通信（Integrated Sensing and Communication, ISAC）**被广泛认为是实现这一目标的关键使能技术之一。ISAC的核心思想是在同一硬件平台上，利用相同的频谱资源同时执行通信和感知功能。这种深度融合带来的优势是显著的：
- 频谱效率提升：通信与感知共用频谱，缓解了日益严峻的频谱稀缺问题。
- 硬件成本降低：共享发射机、接收机和信号处理架构，减少了系统的部署成本和能耗。
- 协调增益：通信与感知的联合设计可带来比独立设计更高的性能增益，例如利用感知结果辅助通信波束对准，或利用通信信号辅助目标探测。
近年来，ISAC已在学术界和工业界引起广泛关注，相关研究覆盖波形设计、波束成形、资源分配、网络架构等多个层面。国际通信顶级会议和期刊已将其列为重点研究方向，3GPP等标准化组织也开始探讨ISAC在未来网络中的标准化路径。
1.1.2 ISAC面临的安全挑战
然而，ISAC在带来技术优势的同时，也引入了传统通信系统未曾面临的安全风险。在纯通信场景中，信息可以通过加密技术和定向波束成形在一定程度上抵御窃听攻击。但在ISAC系统中，用于感知的雷达波束必须向空间各个方向辐射能量，以完成目标检测和跟踪任务。这些辐射信号中不可避免地混杂着通信信息，使得信号能量暴露于广阔的物理空间。
这一"信息承载信号暴露于感知目标"的本质矛盾，带来了以下安全威胁：
- 如果感知目标本身是恶意的（例如敌方无人机或窃听设备），它可以利用接收到的强雷达信号来解码基站的通信内容。
- 相比于传统窃听场景，ISAC中的窃听者（目标）往往处于主波束方向，接收信号质量更好，窃听条件更为有利。
- 感知目标通常难以提前识别和排除，使得传统的基于身份认证的安全机制在此场景下失效。
因此，物理层安全在ISAC系统设计中成为不可忽视的约束条件。与上层加密不同，物理层安全利用无线信道的物理特性（如噪声、衰落、干扰等）来保障信息传输的机密性，具有计算复杂度低、不依赖密钥管理等优势，尤其适合ISAC这类对时延和可靠性要求极高的场景。
1.1.3 智能反射面技术及其安全潜力
**智能反射面（Intelligent Reflecting Surface, IRS，也称为RIS）**是近年来无线通信领域最具颠覆性的硬件技术之一，被认为是B5G/6G网络的关键候选技术。IRS由大量低成本、低功耗的无源反射单元组成，每个单元可通过外部控制器独立调节其电磁特性，从而改变入射信号的相位（甚至幅度）。通过协同控制各单元的反射系数，IRS能够实现所谓的"被动波束成形"，即在不消耗额外发射功率的情况下，将信号能量聚焦于期望的空间方向，或在特定方向形成零陷。
IRS的独特优势使其在物理层安全领域展现出巨大潜力：
- 安全性增强：传统安全增强手段（如人工噪声）需要额外的功率开销，而IRS通过被动反射实现信号增强或干扰抑制，能效极高。
- 隐蔽性强：IRS本身不发射信号，难以被窃听者探测和定位，具有天然的隐蔽性。
- 部署灵活：IRS可以以壁画、窗户贴膜等形式附着于建筑物表面，部署成本低且便于大规模推广。
已有大量文献证明，IRS能够显著提高多输入多输出（MIMO）系统的安全速率，且不增加基站的发射功率负担。在安全通信场景中，IRS可以在增强合法用户信号的同时抑制窃听者的接收质量，或人为地在窃听者方向引入干扰，实现双重安全保障。
将IRS引入ISAC系统具有独特的研究价值。一方面，IRS可以通过被动波束成形提升通信用户的信号质量，增强主信道容量；另一方面，通过调控IRS反射相位，可以使信息泄露信号在目标方向上的功率得到有效抑制，在不牺牲感知性能的前提下保障通信安全。这种双重作用使IRS成为化解ISAC安全矛盾的理想技术平台。
1.1.4 现有研究现状与不足
针对IRS辅助的保密ISAC系统，已有部分文献开展了初步探索提出的方案(文献1（本文为2)，该方案采用基于惩罚法的双层交替优化（Alternating Optimization, AO）算法，通过引入辅助变量将原非凸问题分解为多个子问题，并分别利用拉格朗日对偶、二分搜索和MM（Majorization-Minimization）算法进行求解。
然而，该方法存在不足：
一：解质量受限于交替更新的耦合性。 发射波束矩阵 X \mathbf{X} X 与IRS相移向量 θ \boldsymbol{\theta} θ 在目标函数和约束条件中高度耦合（以乘积形式出现），交替优化在固定一个变量求解另一个时，相当于在"降维空间"中搜索，极易陷入质量较低的局部最优解。尤其在IRS单元数量 N N N 增大时，这种性能退化尤为明显，因为高维空间中变量间的耦合关系更为复杂。
二：收敛缓慢且无法提前终止。 该方法采用双层循环结构，内层循环需反复求解多个子问题，外层循环用于调整惩罚参数，整体迭代次数庞大。更重要的是，在内层循环未完成之前，算法产生的中间解并不满足原始问题的可行性约束（即SINR和功率约束可能被违反），因此无法在信道快速变化的场景中提前终止以获得可用解。这对实际部署构成严重障碍。
1.2 研究意义
本文所研究的SCA-based SOCP方法的核心思想是在每次迭代中，对原始非凸的目标函数和约束条件在当前迭代点处构造凸近似，形成一个可高效求解的凸子问题。与传统方法相比，SCA方法具有以下理论优势：
- 收敛性保证：SCA方法在满足一定条件（如近似函数的梯度一致性、局部紧性等）下，能够保证收敛到原问题的Karush-Kuhn-Tucker (KKT) 稳定点。
- 同步变量更新：与AO方法的"逐一更新"不同，SCA方法将所有变量同时纳入凸子问题中优化，充分考虑了变量间的耦合关系，因此能够获得更高质量的解。
- 可行性保持：SCA的每次迭代均产生满足原始约束的可行解，这对实际工程应用至关重要。
将SCA方法应用于IRS辅助的ISAC安全波束成形问题，扩展了SCA理论在无线通信物理层安全领域的研究边界，为后续更复杂的ISAC场景（如多目标、多IRS、宽带系统等）提供了方法论基础。
2. 系统模型与问题表述
2.1 发射信号
考虑一个RIS辅助的下行保密ISAC系统，包含以下节点：
- 基站（BS） ：配备 L L L 根天线，能够同时发射通信信号和雷达感知信号。
- 智能反射面（RIS） ：由 N N N 个反射单元组成，构成均匀平面阵列。其反射系数矩阵为 Θ = d i a g ( θ ) \boldsymbol{\Theta} = \mathrm{diag}(\boldsymbol{\theta}) Θ=diag(θ)，其中 θ = θ 1 , θ 2 , ... , θ N T \boldsymbol{\theta} = \\theta_1, \\theta_2, \\ldots, \\theta_N^\mathrm{T} θ=θ1,θ2,...,θNT，且 ∣ θ n ∣ = 1 , ∀ n ∈ N = { 1 , ... , N } |\theta_n| = 1, \forall n \in \mathcal{N} = \{1,\ldots,N\} ∣θn∣=1,∀n∈N={1,...,N}。
- 通信用户 ： K K K 个单天线合法用户，集合为 K = { 1 , 2 , ... , K } \mathcal{K} = \{1,2,\ldots,K\} K={1,2,...,K}。
- 感知目标（同时也是潜在窃听者）：一个单天线节点，其与BS之间的直射链路被障碍物阻挡，只能通过IRS反射接收信号。
BS发射的信号为通信信号与雷达信号的线性叠加：
s = ∑ k = 1 K x k w k + ∑ l = 1 L x ^ l w ^ l , (1) \mathbf{s} = \sum_{k=1}^{K} \mathbf{x}k w_k + \sum{l=1}^{L} \hat{\mathbf{x}}_l \hat{w}_l, \tag{1} s=k=1∑Kxkwk+l=1∑Lx^lw^l,(1)
其中 w k w_k wk 和 w ^ l \hat{w}_l w^l 分别是第 k k k 个通信符号和第 l l l 个雷达符号，均独立且均值为零、方差为1。波束成形向量 x k , x ^ l ∈ C L × 1 \mathbf{x}_k, \hat{\mathbf{x}}_l \in \mathbb{C}^{L \times 1} xk,x^l∈CL×1。定义发射波束矩阵为：
X = x 1 , ... , x K , x \^ 1 , ... , x \^ L ∈ C L × ( K + L ) . (2) \mathbf{X} = \\mathbf{x}_1, \\ldots, \\mathbf{x}_K, \\hat{\\mathbf{x}}_1, \\ldots, \\hat{\\mathbf{x}}_L \in \mathbb{C}^{L \times (K+L)}. \tag{2} X=x1,...,xK,x\^1,...,x\^L∈CL×(K+L).(2)
令 M = { 1 , 2 , ... , K + L } \mathcal{M} = \{1,2,\ldots,K+L\} M={1,2,...,K+L} 表示所有波束的索引集合，则 X \mathbf{X} X 的第 m m m 列记为 x ~ m \tilde{\mathbf{x}}_m x~m。
2.2 信道与接收信号
定义BS到RIS的信道矩阵为 G ∈ C N × L \mathbf{G} \in \mathbb{C}^{N \times L} G∈CN×L，BS到第 k k k 个用户的直接链路信道为 h D k ∈ C 1 × L \mathbf{h}{\mathrm{D}k} \in \mathbb{C}^{1 \times L} hDk∈C1×L，RIS到第 k k k 个用户的反射链路信道为 h R k ∈ C 1 × N \mathbf{h}{\mathrm{R}k} \in \mathbb{C}^{1 \times N} hRk∈C1×N。则从BS经IRS到达第 k k k 个用户的等效信道为：
h k = h D k + h R k Θ G . (3) \mathbf{h}k = \mathbf{h}{\mathrm{D}k} + \mathbf{h}_{\mathrm{R}k} \boldsymbol{\Theta} \mathbf{G}. \tag{3} hk=hDk+hRkΘG.(3)
第 k k k 个用户接收的信号为：
y k = h k s + z k , (4) y_k = \mathbf{h}_k \mathbf{s} + z_k, \tag{4} yk=hks+zk,(4)
其中 z k ∼ C N ( 0 , σ k 2 ) z_k \sim \mathcal{CN}(0, \sigma_k^2) zk∼CN(0,σk2) 为加性高斯白噪声。
类似地，定义RIS到目标的信道为 g R ∈ C 1 × N \mathbf{g}_{\mathrm{R}} \in \mathbb{C}^{1 \times N} gR∈C1×N（假设BS到目标的直射链路受阻），则目标处接收信号为：
y T = g s + z T , g = g R Θ G , (5) y_{\mathrm{T}} = \mathbf{g} \mathbf{s} + z_{\mathrm{T}}, \quad \mathbf{g} = \mathbf{g}_{\mathrm{R}} \boldsymbol{\Theta} \mathbf{G}, \tag{5} yT=gs+zT,g=gRΘG,(5)
其中 z T ∼ C N ( 0 , σ T 2 ) z_{\mathrm{T}} \sim \mathcal{CN}(0, \sigma_{\mathrm{T}}^2) zT∼CN(0,σT2) 为目标处噪声。
2.3 性能指标与优化问题
第 k k k 个用户的信干噪比（SINR）为：
γ k = ∣ h k x k ∣ 2 σ k 2 + ∑ ℓ ∈ M ∖ { k } ∣ h k x ~ ℓ ∣ 2 . (6) \gamma_k = \frac{|\mathbf{h}_k \mathbf{x}k|^2}{\sigma_k^2 + \sum{\ell \in \mathcal{M}\setminus\{k\}} |\mathbf{h}k \tilde{\mathbf{x}}\ell|^2}. \tag{6} γk=σk2+∑ℓ∈M∖{k}∣hkx~ℓ∣2∣hkxk∣2.(6)
目标（窃听者）处窃听第 k k k 个用户信息的SINR为：
γ ^ k = ∣ g x k ∣ 2 σ T 2 + ∑ ℓ ∈ M ∖ { k } ∣ g x ~ ℓ ∣ 2 . (7) \hat{\gamma}k = \frac{|\mathbf{g} \mathbf{x}k|^2}{\sigma{\mathrm{T}}^2 + \sum{\ell \in \mathcal{M}\setminus\{k\}} |\mathbf{g} \tilde{\mathbf{x}}_\ell|^2}. \tag{7} γ^k=σT2+∑ℓ∈M∖{k}∣gx~ℓ∣2∣gxk∣2.(7)
目标方向的波束图增益定义为：
G ( X , θ ) = ∑ m ∈ M ∣ g x ~ m ∣ 2 . (8) \mathcal{G}(\mathbf{X}, \boldsymbol{\theta}) = \sum_{m \in \mathcal{M}} |\mathbf{g} \tilde{\mathbf{x}}_m|^2. \tag{8} G(X,θ)=m∈M∑∣gx~m∣2.(8)
优化问题可表述为：
m a x i m i z e X , θ G ( X , θ ) s u b j e c t t o γ k ≥ Γ k , ∀ k ∈ K , γ ^ k ≤ Γ ^ k , ∀ k ∈ K , ∥ X ∥ F 2 ≤ P , ∣ θ n ∣ = 1 , ∀ n ∈ N , (9) \begin{aligned} \underset{\mathbf{X}, \boldsymbol{\theta}}{\mathrm{maximize}} \quad & \mathcal{G}(\mathbf{X}, \boldsymbol{\theta}) \\ \mathrm{subject\ to} \quad & \gamma_k \geq \Gamma_k, \quad \forall k \in \mathcal{K}, \\ & \hat{\gamma}_k \leq \hat{\Gamma}_k, \quad \forall k \in \mathcal{K}, \\ & \|\mathbf{X}\|_F^2 \leq P, \\ & |\theta_n| = 1, \quad \forall n \in \mathcal{N}, \end{aligned} \tag{9} X,θmaximizesubject toG(X,θ)γk≥Γk,∀k∈K,γ^k≤Γ^k,∀k∈K,∥X∥F2≤P,∣θn∣=1,∀n∈N,(9)
其中 Γ k \Gamma_k Γk 和 Γ ^ k \hat{\Gamma}_k Γ^k 分别为通信质量阈值和保密泄漏阈值， P P P 为BS最大发射功率。
该问题显然非凸，原因包括：(i) 目标函数关于 ( X , θ ) (\mathbf{X},\boldsymbol{\theta}) (X,θ) 非凸；(ii) SINR约束涉及分式；(iii) 恒模约束 ∣ θ n ∣ = 1 |\theta_n|=1 ∣θn∣=1 非凸。此外， X \mathbf{X} X 和 θ \boldsymbol{\theta} θ 在多个表达式中以乘积形式耦合，使得直接求解极为困难。
3. 基于SCA的优化算法
3.1 核心思想概述
连续凸近似（SCA）是一种处理非凸优化问题的有效框架。其基本思路为：在每一次迭代中，对原始非凸的目标函数和约束条件，在当前迭代点处构造相应的凸近似函数（通常为下界或上界），从而形成一个可高效求解的凸子问题。求解该子问题得到新的迭代点，重复此过程直至收敛。关键在于，所构造的近似函数需满足SCA的收敛条件，例如梯度一致性、局部紧性等。关于SCA算法的细节和收敛性保证，我往期有文章详细解释过，感兴趣可以自行翻阅
在本文问题中，将目标函数 G ( X , θ ) \mathcal{G}(\mathbf{X},\boldsymbol{\theta}) G(X,θ) 转化为一个凹函数的下界（因为我们要最大化），将SINR约束中的二次项线性化，并通过引入辅助变量将分式约束转为二阶锥形式。最终，每个子问题都转换为一个标准的SOCP，可通过内点法高效求解。
3.2 目标函数的凸近似
首先，对波束图增益进行近似。利用不等式 ∥ u ∥ 2 ≥ 2 ℜ { v H u } − ∥ v ∥ 2 \|\mathbf{u}\|^2 \geq 2\Re\{\mathbf{v}^\mathrm{H}\mathbf{u}\} - \|\mathbf{v}\|^2 ∥u∥2≥2ℜ{vHu}−∥v∥2（在 v \mathbf{v} v 处的一阶泰勒展开下界），以及恒等式 ℜ { u H v } = 1 4 ( ∥ u + v ∥ 2 − ∥ u − v ∥ 2 ) \Re\{\mathbf{u}^\mathrm{H}\mathbf{v}\} = \frac{1}{4}\big(\|\mathbf{u}+\mathbf{v}\|^2 - \|\mathbf{u}-\mathbf{v}\|^2\big) ℜ{uHv}=41(∥u+v∥2−∥u−v∥2)，我们可以在当前迭代点 ( X ( t ) , θ ( t ) ) (\mathbf{X}^{(t)}, \boldsymbol{\theta}^{(t)}) (X(t),θ(t)) 附近构造 G \mathcal{G} G 的凹下界。
具体地，令 g ( t ) = g R Θ ( t ) G \mathbf{g}^{(t)} = \mathbf{g}_{\mathrm{R}}\boldsymbol{\Theta}^{(t)}\mathbf{G} g(t)=gRΘ(t)G， a m ( t ) = g ( t ) x ~ m ( t ) a_m^{(t)} = \mathbf{g}^{(t)}\tilde{\mathbf{x}}_m^{(t)} am(t)=g(t)x~m(t)，以及 b m ( t ) = a m ( t ) ( g ( t ) ) H + x ~ m ( t ) \mathbf{b}_m^{(t)} = a_m^{(t)}(\mathbf{g}^{(t)})^\mathrm{H} + \tilde{\mathbf{x}}_m^{(t)} bm(t)=am(t)(g(t))H+x~m(t)。经过一系列代数运算，可得到：
G ( X , θ ) ≥ ∑ m ∈ M f m ( x ~ m , θ ; x ~ m ( t ) , θ ( t ) ) , (10) \mathcal{G}(\mathbf{X}, \boldsymbol{\theta}) \geq \sum_{m \in \mathcal{M}} f_m(\tilde{\mathbf{x}}_m, \boldsymbol{\theta}; \tilde{\mathbf{x}}_m^{(t)}, \boldsymbol{\theta}^{(t)}), \tag{10} G(X,θ)≥m∈M∑fm(x~m,θ;x~m(t),θ(t)),(10)
其中 f m f_m fm 是一个关于 x ~ m \tilde{\mathbf{x}}_m x~m 和 θ \boldsymbol{\theta} θ 的联合凹函数（具体形式见论文中的式(9)）。该下界是通过对原目标函数中的二次项依次应用线性化得到的，保证了在每次迭代中，最大化该下界等同于向原目标函数的局部最优方向推进。
3.3 SINR约束的凸化
考虑用户 k k k 的SINR约束 γ k ≥ Γ k \gamma_k \geq \Gamma_k γk≥Γk。将其改写为：
1 Γ k ∣ h k x k ∣ 2 ≥ σ k 2 + ∑ ℓ ∈ M ∖ { k } ∣ h k x ~ ℓ ∣ 2 . (11) \frac{1}{\Gamma_k} |\mathbf{h}_k \mathbf{x}k|^2 \geq \sigma_k^2 + \sum{\ell \in \mathcal{M}\setminus\{k\}} |\mathbf{h}k \tilde{\mathbf{x}}\ell|^2. \tag{11} Γk1∣hkxk∣2≥σk2+ℓ∈M∖{k}∑∣hkx~ℓ∣2.(11)
左侧是凸函数 ∣ ⋅ ∣ 2 |\cdot|^2 ∣⋅∣2 在 h k \mathbf{h}_k hk 上的二次型，但由于变量 ( X , θ ) (\mathbf{X},\boldsymbol{\theta}) (X,θ) 耦合，直接处理困难。我们仿照目标函数的做法，在当前点对左侧进行凹下界近似，得到：
1 Γ k ∣ h k x k ∣ 2 ≥ 1 Γ k f ˉ k ( x k , θ ; x k ( t ) , θ ( t ) ) , (12) \frac{1}{\Gamma_k} |\mathbf{h}_k \mathbf{x}_k|^2 \geq \frac{1}{\Gamma_k} \bar{f}_k(\mathbf{x}_k, \boldsymbol{\theta}; \mathbf{x}_k^{(t)}, \boldsymbol{\theta}^{(t)}), \tag{12} Γk1∣hkxk∣2≥Γk1fˉk(xk,θ;xk(t),θ(t)),(12)
其中 f ˉ k \bar{f}_k fˉk 为凹函数。同时，右侧的平方项求和是凸的，无需改动。这样，约束 (11) 便被替换为：
1 Γ k f ˉ k ( x k , θ ) ≥ σ k 2 + ∑ ℓ ≠ k ∣ h k x ~ ℓ ∣ 2 , (13) \frac{1}{\Gamma_k} \bar{f}_k(\mathbf{x}k, \boldsymbol{\theta}) \geq \sigma_k^2 + \sum{\ell \neq k} |\mathbf{h}k \tilde{\mathbf{x}}\ell|^2, \tag{13} Γk1fˉk(xk,θ)≥σk2+ℓ=k∑∣hkx~ℓ∣2,(13)
这已成为一个凸约束（左侧凹函数 ≥ 凸函数）。
另外，为了将约束转化为SOCP形式，还需要引入辅助变量 ϕ k ℓ \phi_{k\ell} ϕkℓ 和 ϕ ˉ k ℓ \bar{\phi}_{k\ell} ϕˉkℓ 来分别约束 ℜ { h k x ~ ℓ } \Re\{\mathbf{h}k \tilde{\mathbf{x}}\ell\} ℜ{hkx~ℓ} 和 ℑ { h k x ~ ℓ } \Im\{\mathbf{h}k \tilde{\mathbf{x}}\ell\} ℑ{hkx~ℓ} 的绝对值，并通过线性化将绝对值约束转化为二阶锥。具体推导见论文式(10)-(16)。
3.4 信息泄漏约束的凸化
信息泄漏约束 γ ^ k ≤ Γ ^ k \hat{\gamma}_k \leq \hat{\Gamma}_k γ^k≤Γ^k 可等价写为：
σ T 2 + ∑ ℓ ∈ M ∖ { k } ∣ g x ~ ℓ ∣ 2 ≥ 1 Γ ^ k ∣ g x k ∣ 2 . (14) \sigma_{\mathrm{T}}^2 + \sum_{\ell \in \mathcal{M}\setminus\{k\}} |\mathbf{g} \tilde{\mathbf{x}}_\ell|^2 \geq \frac{1}{\hat{\Gamma}_k} |\mathbf{g} \mathbf{x}_k|^2. \tag{14} σT2+ℓ∈M∖{k}∑∣gx~ℓ∣2≥Γ^k1∣gxk∣2.(14)
左侧是多个平方项之和，其在当前点处的凹下界可由目标函数类似的方法构造；右侧的平方项则需凸上界，即引入辅助变量 τ k \tau_k τk 和 τ ˉ k \bar{\tau}_k τˉk 分别约束实部和虚部绝对值，并将 ( ∣ ℜ ∣ 2 + ∣ ℑ ∣ 2 ) (|\Re|^2 + |\Im|^2) (∣ℜ∣2+∣ℑ∣2) 放缩为 τ k 2 + τ ˉ k 2 \tau_k^2 + \bar{\tau}_k^2 τk2+τˉk2。最终，约束 (14) 转化为一组线性不等式和二阶锥约束，详见论文式(17)-(20)。
3.5 恒模约束的处理
对于 ∣ θ n ∣ = 1 |\theta_n| = 1 ∣θn∣=1，我们首先将其松弛为 ∣ θ n ∣ ≤ 1 |\theta_n| \leq 1 ∣θn∣≤1。由于最大化目标函数倾向于增大信号功率，松弛后约束在最优解处通常会取到等号，因此可行解仍满足原始恒模条件。进一步， ∣ θ n ∣ ≤ 1 |\theta_n| \leq 1 ∣θn∣≤1 可等价于一个二阶锥约束： ∥ 0 , ℜ { θ n } , ℑ { θ n } ∥ 2 ≤ 1 \|\mathbf{0}, \Re\{\theta_n\}, \Im\{\theta_n\}\|_2 \leq 1 ∥0,ℜ{θn},ℑ{θn}∥2≤1，其凸性显然。
为了加速收敛，在目标函数中可加入一个正则化项 − ζ ∥ θ − θ ( t ) ∥ 2 - \zeta \|\boldsymbol{\theta} - \boldsymbol{\theta}^{(t)}\|^2 −ζ∥θ−θ(t)∥2，鼓励 θ \boldsymbol{\theta} θ 不要偏离当前点过远，这有助于保证SCA的稳定收敛。
3.6 最终SOCP子问题
综合以上所有近似，在第 t t t 次迭代，形成如下SOCP：
该问题为标准SOCP，可由商用求解器（如MOSEK、CPLEX）高效求解。求解后得到新点 ( X ( t + 1 ) , θ ( t + 1 ) ) (\mathbf{X}^{(t+1)}, \boldsymbol{\theta}^{(t+1)}) (X(t+1),θ(t+1))，重复迭代直至收敛（如目标函数相对变化小于阈值 ϵ \epsilon ϵ）。
3.7 初始可行点获取
SCA需要初始可行点。论文提出一种实用的策略：求解一个松弛可行问题，即允许SINR约束和泄漏约束被松弛变量 δ k \delta_k δk 和 δ ˉ k \bar{\delta}_k δˉk 放宽，并最小化 ∑ ( δ k + δ ˉ k ) \sum(\delta_k + \bar{\delta}_k) ∑(δk+δˉk)。该问题始终可行，当目标函数降至零时，原问题可行，即可获得初始点。若松弛最小值为正，则声明原问题在当前信道条件下不可行。即：
3.8. 算法复杂度分析
在第 t t t 次迭代中，SOCP子问题包含的实变量数量约为 2 L ( K + L ) + 2 N 2L(K+L) + 2N 2L(K+L)+2N 的量级，约束数量与 K 2 + K L + N K^2 + KL + N K2+KL+N 成正比。根据内点法复杂度理论（见19），求解一个SOCP的迭代复杂度为 O ( m ) \mathcal{O}(\sqrt{m}) O(m )，其中 m m m 为约束数，每次内点迭代的算术运算量为变量数的立方量级。因此，整体每迭代一次的计算复杂度约为：
O ( ( K 2 + K L + N ) 1.5 ⋅ ( K 2 + K L + L 2 + N ) ) . (16) \mathcal{O}\big( (K^2 + KL + N)^{1.5} \cdot (K^2 + KL + L^2 + N) \big). \tag{16} O((K2+KL+N)1.5⋅(K2+KL+L2+N)).(16)
当 N N N 远大于 K K K 和 L L L 时（实际IRS通常有数百单元），上式可近似为 O ( N 3.5 ) \mathcal{O}(N^{3.5}) O(N3.5)。相比之下，传统AO方法的每迭代复杂度约为 O ( N 3 ) \mathcal{O}(N^3) O(N3)，SCA的单次迭代看似更高。然而，由于SCA的收敛速度远快于AO（SCA通常只需数十次迭代即可收敛，而AO往往需要数百次），整体求解时间反而更短。
3.9. 复现结果
仿真参数表
| 参数符号 | 参数含义 | 取值 | 备注 |
|---|---|---|---|
| L L L | BS天线数 | 4 | |
| Q Q Q | 雷达波束数（感知信号流数） | 4 | |
| K K K | 通信用户数 | 3 | |
| N N N | IRS反射单元总数 | 36 | |
| Γ k \Gamma_k Γk | 用户SINR阈值 | 10 dB | 所有用户相同 |
| Γ ^ k \hat{\Gamma}_k Γ^k | 信息泄漏阈值 | 0 dB | 所有用户相同 |
| σ 2 \sigma^2 σ2 | 噪声功率 | − 120 -120 −120 dBm（即 10 − 12 10^{-12} 10−12 W） | |
| P P P | 发射功率预算 | 30 dBm | |
| ϵ \epsilon ϵ | SCA收敛容差 | 10 − 3 10^{-3} 10−3 | 相对变化阈值 |
| ζ \zeta ζ | 正则化参数 | 0.001 0.001 0.001 | 用于目标函数中的近端项 |
| 蒙特卡洛次数 | 独立信道实现数 | 100 | 论文中取值，复现时可调整 |
| 最大迭代次数 | SCA主循环上限 | 200 | 防止不收敛 |
| 信道模型 | BS-RIS / RIS-用户 | 莱斯衰落（Rician factor = 3 dB） | 含路径损耗 |
| 信道模型 | BS-用户 | 瑞利衰落 | 含路径损耗 |
| 信道模型 | IRS-目标 | 视距（LOS） steering vector | 目标方向已知 |
| 求解器 | 二阶锥规划求解 | MOSEK v10.0.40 | 商用内点法求解器 |
从复现结果可以看到：
- 算法几十步内迭代收敛
- RIS的反射元件的增加会提升雷达波束的增益。和文章结果基本一致。
部分代码：
c
import numpy as np
from mosek.fusion import *
import sys
import itertools
# 定义光标符号
cursor_symbols = itertools.cycle(['-', '\\', '|', '/'])
# 矩阵Hermitian算子
def Herm(x):
"""
:param x: 输入矩阵
:return: 输入矩阵的共轭转置
"""
return x.conj().T
# 基于SCA的算法寻找可行点
def SCA_feasible(arg, channels, xTildeCurrent, thetaVecCurrent):
# 解包参数
Nb, K, Nr, Ns, Pmax, gamma, gammaR, zeta = arg.Nb, arg.K, arg.Q, arg.Ns, arg.Pmax, arg.gamma, arg.gammaR, arg.zeta
# 解包信道
G, hD, hRelayed, gRelayed, scaledNoisePower, sf = channels
hCurrent = hD + hRelayed @ np.diag(thetaVecCurrent) @ G
gCurrent = gRelayed @ np.diag(thetaVecCurrent) @ G
thetaVecNormSqCurrent = np.linalg.norm(thetaVecCurrent) ** 2
# ------ MOSEK模型
initialModel = Model()
# ------------- 变量 --------------------
xtildeR = initialModel.variable('xtildeR', [Nb, K + Nr], Domain.unbounded()) # 变量xtilde的实部
xtildeI = initialModel.variable('xtildeI', [Nb, K + Nr], Domain.unbounded()) # 变量xtilde的虚部
thetaR = initialModel.variable('thetaR', [Ns, 1], Domain.unbounded()) # 变量theta的实部
thetaI = initialModel.variable('thetaI', [Ns, 1], Domain.unbounded()) # 变量theta的虚部
t = initialModel.variable('t', [K, K + Nr], Domain.unbounded()) # 变量t
tBar = initialModel.variable('tBar', [K, K + Nr], Domain.unbounded()) # 变量tBar
tau = initialModel.variable('tau', K, Domain.unbounded()) # 变量tau
tauBar = initialModel.variable('tauBar', K, Domain.unbounded()) # 变量tauBar
omega = initialModel.variable('omega', K, Domain.greaterThan(0.0))
omegaBar = initialModel.variable('omegaBar', K, Domain.greaterThan(0.0))
xtildeRTranspose = xtildeR.transpose()
xtildeITranspose = xtildeI.transpose()
# ------ BS-用户信道
hR = Expr.sub(Expr.sub(Expr.sub(Expr.add(hD.real,
Expr.mul(
Expr.mulElm(hRelayed.real,
Expr.transpose(Expr.repeat(thetaR, K, 1))),
G.real)),
Expr.mul(Expr.mulElm(hRelayed.real, Expr.transpose(Expr.repeat(thetaI, K, 1))),
G.imag)),
Expr.mul(Expr.mulElm(hRelayed.imag, Expr.transpose(Expr.repeat(thetaR, K, 1))), G.imag)),
Expr.mul(Expr.mulElm(hRelayed.imag, Expr.transpose(Expr.repeat(thetaI, K, 1))), G.real))
# 有效BS-用户信道的实部
hRTranspose = Expr.transpose(hR) # hR的转置
hI = Expr.sub(Expr.add(Expr.add(Expr.add(hD.imag,
Expr.mul(
Expr.mulElm(hRelayed.real,
Expr.transpose(Expr.repeat(thetaR, K, 1))),
G.imag)),
Expr.mul(Expr.mulElm(hRelayed.real, Expr.transpose(Expr.repeat(thetaI, K, 1))),
G.real)),
Expr.mul(Expr.mulElm(hRelayed.imag, Expr.transpose(Expr.repeat(thetaR, K, 1))), G.real)),
Expr.mul(Expr.mulElm(hRelayed.imag, Expr.transpose(Expr.repeat(thetaI, K, 1))), G.imag))
# 有效BS-用户信道的虚部
hITranspose = Expr.transpose(hI) # hI的转置
# ------ BS-目标信道
gR = Expr.sub(Expr.sub(Expr.sub(Expr.mul(Expr.mulElm(gRelayed[None, :].real, Expr.transpose(thetaR)), G.real),
Expr.mul(Expr.mulElm(gRelayed[None, :].real, Expr.transpose(thetaI)), G.imag)),
Expr.mul(Expr.mulElm(gRelayed[None, :].imag, Expr.transpose(thetaR)), G.imag)),
Expr.mul(Expr.mulElm(gRelayed[None, :].imag, Expr.transpose(thetaI)), G.real))
# 有效BS-目标信道的实部
gRTranspose = Expr.transpose(gR) # gR的转置
gI = Expr.sub(Expr.add(Expr.add(Expr.mul(Expr.mulElm(gRelayed[None, :].real, Expr.transpose(thetaR)), G.imag),
Expr.mul(Expr.mulElm(gRelayed[None, :].real, Expr.transpose(thetaI)), G.real)),
Expr.mul(Expr.mulElm(gRelayed[None, :].imag, Expr.transpose(thetaR)), G.real)),
Expr.mul(Expr.mulElm(gRelayed[None, :].imag, Expr.transpose(thetaI)), G.imag))
# 有效BS-用户信道的虚部
gITranspose = Expr.transpose(gI) # gI的转置
# ------------- 目标函数 --------------------
obj = Expr.sub(Expr.add(Expr.sum(omega), Expr.sum(omegaBar)),
Expr.mul(zeta, Expr.sub(Expr.add(Expr.dot(2 * thetaVecCurrent.real, thetaR),
Expr.dot(2 * thetaVecCurrent.imag, thetaI)),
thetaVecNormSqCurrent)))
initialModel.objective("obj", ObjectiveSense.Minimize, obj) # 目标函数
# ------ 计算目标函数中的常数
aCurrent, aAbsSQ, bCurrentR, bCurrentI, \
bCurrentNormSQ, delta1, delta2 = computeParameterSet1(Nb, K, Nr, gCurrent, xTildeCurrent)
aR = aCurrent.real
aI = aCurrent.imag
# ------------- 发射功率约束（见式7d）
tpCone = Expr.flatten(Expr.hstack(xtildeR, xtildeI))
initialModel.constraint(Expr.vstack(np.sqrt(Pmax), tpCone), Domain.inQCone())
# ------------- 松弛的单位模约束（见式18i）
initialModel.constraint(Expr.hstack(Expr.constTerm(Matrix.ones(Ns, 1)), Expr.hstack(thetaR, thetaI)),
Domain.inQCone())
# ------------- 计算第二组常数
cCurrent, cAbsSQ, dCurrentR, dCurrentI, \
dCurrentNormSQ, delta3, delta4 = computeParameterSet2(Nb, K, hCurrent, xTildeCurrent)
cR = cCurrent.real
cI = cCurrent.imag
for k in range(K):
# --------------- 约束 (18c)
lhsB = Expr.add(
Expr.sub(
Expr.mul(Expr.sub(Expr.add(Expr.add(Expr.add(Expr.dot(delta3[k, :], hR.slice([k, 0], [k + 1, Nb])),
Expr.dot(delta4[k, :],
hI.slice([k, 0], [k + 1, Nb]))),
Expr.dot(dCurrentR[:, k].T,
xtildeR.slice([0, k], [Nb, k + 1]))),
Expr.dot(dCurrentI[:, k].T, xtildeI.slice([0, k], [Nb, k + 1]))),
0.5 * dCurrentNormSQ[k] + cAbsSQ[k]), 1 / gamma), scaledNoisePower),
omega.pick([k]))
rhsB = Expr.hstack(Expr.hstack(
Expr.hstack(Expr.hstack(Expr.reshape(t.pick([[k, j] for j in range(K + Nr) if j != k]), 1, K + Nr - 1),
Expr.reshape(tBar.pick([[k, j] for j in range(K + Nr) if j != k]), 1,
K + Nr - 1)),
Expr.mul(Expr.sub(Expr.add(Expr.mul(hR.slice([k, 0], [k + 1, Nb]), cR[k]),
Expr.mul(hI.slice([k, 0], [k + 1, Nb]), cI[k])),
xtildeRTranspose.slice([k, 0], [k + 1, Nb])),
np.sqrt(1 / (2 * gamma)))),
Expr.mul(Expr.sub(Expr.sub(Expr.mul(hR.slice([k, 0], [k + 1, Nb]), cI[k]),
Expr.mul(hI.slice([k, 0], [k + 1, Nb]), cR[k])),
xtildeITranspose.slice([k, 0], [k + 1, Nb])),
np.sqrt(1 / (2 * gamma)))),
Expr.mul(Expr.sub(lhsB, 1), 1 / 2))
lhsB = Expr.mul(Expr.add(lhsB, 1), 1 / 2)
initialModel.constraint(Expr.hstack(lhsB, rhsB), Domain.inQCone())
# --------------- 计算第三组常数
Lambda, LambdaTilde, normCSQ, eta, etaTilde, normDSQ, \
psi, psiTilde, normESQ, phi, phiTilde, normFSQ \
= ComputeParametersSet3(k, K, Nr, hCurrent, xTildeCurrent)
# --------------- 约束 (18d)
lhsC = Expr.add(Expr.add(Expr.reshape(t.pick([[k, l] for l in range(K + Nr) if l != k]), K + Nr - 1, 1),
Expr.reshape(Expr.mulDiag(0.5 * Lambda,
Expr.sub(Expr.repeat(hRTranspose.slice([0, k], [Nb, k + 1]),
K + Nr - 1, 1),
Expr.transpose(Expr.reshape(
Expr.flatten(xtildeRTranspose).pick(
[[l] for l in range((K + Nr) * Nb)
if ((l < k * Nb) or (
l >= k * Nb + Nb))]),
(K + Nr) - 1, Nb)))), K + Nr - 1, 1)),
Expr.reshape(Expr.mulDiag(0.5 * LambdaTilde,
Expr.add(
Expr.repeat(hITranspose.slice([0, k], [Nb, k + 1]),
K + Nr - 1,
1),
Expr.transpose(Expr.reshape(
Expr.flatten(xtildeITranspose).pick(
[[l] for l in range((K + Nr) * Nb) if
((l < k * Nb) or (l >= k * Nb + Nb))]),
(K + Nr) - 1, Nb)))), K + Nr - 1, 1))
rhsC = Expr.mul(Expr.sub(lhsC, 1 + 0.25 * normCSQ), 0.5)
lhsC = Expr.mul(Expr.add(lhsC, 1 - 0.25 * normCSQ), 0.5)
rhsC = Expr.hstack(Expr.hstack(rhsC,
Expr.mul(Expr.sub(
Expr.reshape(Expr.flatten(xtildeITranspose).pick(
[[l] for l in range((K + Nr) * Nb) if
((l < k * Nb) or (l >= k * Nb + Nb))]), K + Nr - 1, Nb),
Expr.repeat(hI.slice([k, 0], [k + 1, Nb]), K + Nr - 1, 0)), 0.5)),
Expr.mul(Expr.add(
Expr.reshape(Expr.flatten(xtildeRTranspose).pick(
[[l] for l in range((K + Nr) * Nb) if ((l < k * Nb) or (l >= k * Nb + Nb))]),
K + Nr - 1, Nb),
Expr.repeat(hR.slice([k, 0], [k + 1, Nb]), K + Nr - 1, 0)), 0.5))
initialModel.constraint(Expr.hstack(lhsC, rhsC), Domain.inQCone())
# --------------- 约束 (18e)
lhsD = Expr.add(Expr.add(Expr.reshape(t.pick([[k, l] for l in range(K + Nr) if l != k]), K + Nr - 1, 1),
Expr.reshape(Expr.mulDiag(0.5 * eta,
Expr.add(Expr.repeat(hRTranspose.slice([0, k], [Nb, k + 1]),
K + Nr - 1, 1),
Expr.transpose(Expr.reshape(
Expr.flatten(xtildeRTranspose).pick(
[[l] for l in range((K + Nr) * Nb)
if ((l < k * Nb) or (
l >= k * Nb + Nb))]),
(K + Nr) - 1, Nb)))), K + Nr - 1, 1)),
Expr.reshape(Expr.mulDiag(0.5 * etaTilde,
Expr.sub(
Expr.repeat(hITranspose.slice([0, k], [Nb, k + 1]),
K + Nr - 1,
1),
Expr.transpose(Expr.reshape(
Expr.flatten(xtildeITranspose).pick(
[[l] for l in range((K + Nr) * Nb) if
((l < k * Nb) or (l >= k * Nb + Nb))]),
(K + Nr) - 1, Nb)))), K + Nr - 1, 1))
rhsD = Expr.mul(Expr.sub(lhsD, 1 + 0.25 * normDSQ), 0.5)
lhsD = Expr.mul(Expr.add(lhsD, 1 - 0.25 * normDSQ), 0.5)
rhsD = Expr.hstack(Expr.hstack(rhsD,
Expr.mul(Expr.add(
Expr.reshape(Expr.flatten(xtildeITranspose).pick(
[[l] for l in range((K + Nr) * Nb) if
((l < k * Nb) or (l >= k * Nb + Nb))]), K + Nr - 1, Nb),
Expr.repeat(hI.slice([k, 0], [k + 1, Nb]), K + Nr - 1, 0)), 0.5)),
Expr.mul(Expr.sub(Expr.repeat(hR.slice([k, 0], [k + 1, Nb]), K + Nr - 1, 0),
Expr.reshape(
Expr.flatten(xtildeRTranspose).pick(
[[l] for l in range((K + Nr) * Nb) if
((l < k * Nb) or (l >= k * Nb + Nb))]), K + Nr - 1, Nb)),
0.5))
initialModel.constraint(Expr.hstack(lhsD, rhsD), Domain.inQCone())
# --------------- 约束 (18f)
lhsE = Expr.add(Expr.add(Expr.reshape(tBar.pick([[k, l] for l in range(K + Nr) if l != k]), K + Nr - 1, 1),
Expr.reshape(Expr.mulDiag(0.5 * psi,
Expr.sub(Expr.repeat(hRTranspose.slice([0, k], [Nb, k + 1]),
K + Nr - 1, 1),
Expr.transpose(Expr.reshape(
Expr.flatten(xtildeITranspose).pick(
[[l] for l in range((K + Nr) * Nb)
if ((l < k * Nb) or (
l >= k * Nb + Nb))]),
K + Nr - 1, Nb)))), K + Nr - 1, 1)),
Expr.reshape(Expr.mulDiag(0.5 * psiTilde,
Expr.sub(
Expr.repeat(hITranspose.slice([0, k], [Nb, k + 1]),
K + Nr - 1,
1),
Expr.transpose(Expr.reshape(
Expr.flatten(xtildeRTranspose).pick(
[[l] for l in range((K + Nr) * Nb) if
((l < k * Nb) or (l >= k * Nb + Nb))]),
K + Nr - 1, Nb)))), K + Nr - 1, 1))
rhsE = Expr.mul(Expr.sub(lhsE, 1 + 0.25 * normESQ), 0.5)
lhsE = Expr.mul(Expr.add(lhsE, 1 - 0.25 * normESQ), 0.5)
rhsE = Expr.hstack(Expr.hstack(rhsE,
Expr.mul(Expr.add(Expr.reshape(
Expr.flatten(xtildeRTranspose).pick([[l] for l in range((K + Nr) * Nb) if
((l < k * Nb) or (
l >= k * Nb + Nb))]),
K + Nr - 1, Nb),
Expr.repeat(hI.slice([k, 0], [k + 1, Nb]), K + Nr - 1, 0)), 0.5)),
Expr.mul(Expr.add(Expr.reshape(
Expr.flatten(xtildeITranspose).pick(
[[l] for l in range((K + Nr) * Nb) if ((l < k * Nb) or (l >= k * Nb + Nb))]),
K + Nr - 1, Nb),
Expr.repeat(hR.slice([k, 0], [k + 1, Nb]), K + Nr - 1, 0)), 0.5))
initialModel.constraint(Expr.hstack(lhsE, rhsE), Domain.inQCone())
# --------------- 约束 (18g)
lhsF = Expr.add(Expr.add(Expr.reshape(tBar.pick([[k, l] for l in range(K + Nr) if l != k]), K + Nr - 1, 1),
Expr.reshape(Expr.mulDiag(0.5 * phi,
Expr.add(Expr.repeat(hRTranspose.slice([0, k], [Nb, k + 1]),
K + Nr - 1, 1),
Expr.transpose(Expr.reshape(
Expr.flatten(xtildeITranspose).pick(
[[l] for l in range((K + Nr) * Nb)
if ((l < k * Nb) or (
l >= k * Nb + Nb))]),
K + Nr - 1, Nb)))), K + Nr - 1, 1)),
Expr.reshape(Expr.mulDiag(0.5 * phiTilde,
Expr.add(
Expr.repeat(hITranspose.slice([0, k], [Nb, k + 1]),
K + Nr - 1,
1),
Expr.transpose(Expr.reshape(
Expr.flatten(xtildeRTranspose).pick(
[[l] for l in range((K + Nr) * Nb) if
((l < k * Nb) or (l >= k * Nb + Nb))]),
K + Nr - 1, Nb)))), K + Nr - 1, 1))
rhsF = Expr.mul(Expr.sub(lhsF, 1 + 0.25 * normFSQ), 0.5)
lhsF = Expr.mul(Expr.add(lhsF, 1 - 0.25 * normFSQ), 0.5)
rhsF = Expr.hstack(Expr.hstack(rhsF,
Expr.mul(Expr.sub(Expr.reshape(
Expr.flatten(xtildeRTranspose).pick([[l] for l in range((K + Nr) * Nb) if
((l < k * Nb) or (
l >= k * Nb + Nb))]),
K + Nr - 1, Nb),
Expr.repeat(hI.slice([k, 0], [k + 1, Nb]), K + Nr - 1, 0)), 0.5)),
Expr.mul(Expr.sub(Expr.repeat(hR.slice([k, 0], [k + 1, Nb]), K + Nr - 1, 0),
Expr.reshape(
Expr.flatten(xtildeITranspose).pick(
[[l] for l in range((K + Nr) * Nb) if
((l < k * Nb) or (l >= k * Nb + Nb))]), K + Nr - 1, Nb)),
0.5))
initialModel.constraint(Expr.hstack(lhsF, rhsF), Domain.inQCone())
# --------------- 约束 (18g)
secureLHS = Expr.add(Expr.add(
Expr.sub(Expr.add(Expr.add(Expr.add(Expr.sum(Expr.mul(delta1[np.arange(K + Nr) != k, :], gRTranspose)),
Expr.sum(Expr.mul(delta2[np.arange(K + Nr) != k, :], gITranspose))),
Expr.sum(Expr.mulDiag(bCurrentR[:, np.arange(K + Nr) != k].T,
Expr.transpose(Expr.reshape(
Expr.flatten(xtildeRTranspose).pick(
[[l] for l in range((K + Nr) * Nb) if
((l < k * Nb) or (
l >= k * Nb + Nb))]),
(K + Nr) - 1, Nb))))),
Expr.sum(
Expr.mulDiag(bCurrentI[:, np.arange(K + Nr) != k].T, Expr.transpose(Expr.reshape(
Expr.flatten(xtildeITranspose).pick([[l] for l in range((K + Nr) * Nb) if
((l < k * Nb) or (
l >= k * Nb + Nb))]),
(K + Nr) - 1, Nb))))),
np.sum(0.5 * bCurrentNormSQ[np.arange(K + Nr) != k] + aAbsSQ[np.arange(K + Nr) != k])),
scaledNoisePower),
omegaBar.pick([k]))
secureRHS = Expr.flatten(Expr.sub(
Expr.add(
Expr.mulElm(np.tile(aR[np.arange(K + Nr) != k], (Nb, 1)), Expr.repeat(gRTranspose, K + Nr - 1, 1)),
Expr.mulElm(np.tile(aI[np.arange(K + Nr) != k], (Nb, 1)),
Expr.repeat(gITranspose, K + Nr - 1, 1))), Expr.transpose(Expr.reshape(
Expr.flatten(xtildeRTranspose).pick(
[[l] for l in range((K + Nr) * Nb) if ((l < k * Nb) or (l >= k * Nb + Nb))]),
(K + Nr) - 1,
Nb))))
secureRHS = Expr.vstack(secureRHS, Expr.flatten(Expr.sub(
Expr.sub(
Expr.mulElm(np.tile(aI[np.arange(K + Nr) != k], (Nb, 1)), Expr.repeat(gRTranspose, K + Nr - 1, 1)),
Expr.mulElm(np.tile(aR[np.arange(K + Nr) != k], (Nb, 1)),
Expr.repeat(gITranspose, K + Nr - 1, 1))),
Expr.transpose(Expr.reshape(Expr.flatten(xtildeITranspose).pick(
[[l] for l in range((K + Nr) * Nb) if ((l < k * Nb) or (l >= k * Nb + Nb))]), (K + Nr) - 1,
Nb)))))
secureRHS = Expr.vstack(
Expr.vstack(Expr.mul(tau.pick([k]), 1 / np.sqrt(gammaR)),
Expr.mul(tauBar.pick([k]), 1 / np.sqrt(gammaR))),
Expr.mul(secureRHS, np.sqrt(0.5)))
secureRHS = Expr.vstack(secureRHS, Expr.mul(Expr.sub(secureLHS, 1), 0.5))
secureLHS = Expr.mul(Expr.add(secureLHS, 1), 0.5)
initialModel.constraint(Expr.vstack(secureLHS, secureRHS), Domain.inQCone())
# ------------------------------------
eta1, eta2, etaBar1, etaBar2, chi1, chi2, chiBar1, chiBar2, \
etaNormSQ, etaBarNormSQ, chiNormSQ, chiBarNormSQ = computeParameterSet4(k, gCurrent, xTildeCurrent)
etaLHS = Expr.add(
Expr.add(tau.pick([k]),
Expr.dot(0.5 * eta1, Expr.sub(gRTranspose, xtildeR.slice([0, k], [Nb, k + 1])))),
Expr.dot(0.5 * eta2, Expr.add(gITranspose, xtildeI.slice([0, k], [Nb, k + 1]))))
etaRHS = Expr.mul(Expr.sub(etaLHS, 1 + 0.25 * etaNormSQ), 0.5)
etaLHS = Expr.mul(Expr.add(etaLHS, 1 - 0.25 * etaNormSQ), 0.5)
etaRHS = Expr.hstack(
Expr.hstack(etaRHS,
Expr.mul(Expr.sub(Expr.reshape(xtildeI.slice([0, k], [Nb, k + 1]), 1, Nb), gI), 0.5)),
Expr.mul(Expr.add(Expr.reshape(xtildeR.slice([0, k], [Nb, k + 1]), 1, Nb), gR), 0.5))
initialModel.constraint(Expr.hstack(etaLHS, etaRHS), Domain.inQCone())
# ------------------------------------
etaBarLHS = Expr.add(
Expr.add(tau.pick([k]),
Expr.dot(0.5 * etaBar1, Expr.add(gRTranspose, xtildeR.slice([0, k], [Nb, k + 1])))),
Expr.dot(0.5 * etaBar2, Expr.sub(gITranspose, xtildeI.slice([0, k], [Nb, k + 1]))))
etaBarRHS = Expr.mul(Expr.sub(etaBarLHS, 1 + 0.25 * etaBarNormSQ), 0.5)
etaBarLHS = Expr.mul(Expr.add(etaBarLHS, 1 - 0.25 * etaBarNormSQ), 0.5)
etaBarRHS = Expr.hstack(Expr.hstack(etaBarRHS, Expr.mul(
Expr.add(Expr.reshape(xtildeI.slice([0, k], [Nb, k + 1]), 1, Nb), gI), -0.5)),
Expr.mul(Expr.sub(gR, Expr.reshape(xtildeR.slice([0, k], [Nb, k + 1]), 1, Nb)), 0.5))
initialModel.constraint(Expr.hstack(etaBarLHS, etaBarRHS), Domain.inQCone())
# ------------------------------------
chiLHS = Expr.add(
Expr.add(tauBar.pick([k]),
Expr.dot(0.5 * chi1, Expr.sub(gRTranspose, xtildeI.slice([0, k], [Nb, k + 1])))),
Expr.dot(0.5 * chi2, Expr.sub(gITranspose, xtildeR.slice([0, k], [Nb, k + 1]))))
chiRHS = Expr.mul(Expr.sub(chiLHS, 1 + 0.25 * chiNormSQ), 0.5)
chiLHS = Expr.mul(Expr.add(chiLHS, 1 - 0.25 * chiNormSQ), 0.5)
chiRHS = Expr.hstack(
Expr.hstack(chiRHS,
Expr.mul(Expr.add(Expr.reshape(xtildeR.slice([0, k], [Nb, k + 1]), 1, Nb), gI), -0.5)),
Expr.mul(Expr.add(Expr.reshape(xtildeI.slice([0, k], [Nb, k + 1]), 1, Nb), gR), 0.5))
initialModel.constraint(Expr.hstack(chiLHS, chiRHS), Domain.inQCone())
# ------------------------------------
chiBarLHS = Expr.add(Expr.add(tauBar.pick([k]), Expr.dot(0.5 * chiBar1, Expr.add(gRTranspose,
xtildeI.slice([0, k],
[Nb, k + 1])))),
Expr.dot(0.5 * chiBar2, Expr.add(gITranspose, xtildeR.slice([0, k], [Nb, k + 1]))))
chiBarRHS = Expr.mul(Expr.sub(chiBarLHS, 1 + 0.25 * chiBarNormSQ), 0.5)
chiBarLHS = Expr.mul(Expr.add(chiBarLHS, 1 - 0.25 * chiBarNormSQ), 0.5)
chiBarRHS = Expr.hstack(Expr.hstack(chiBarRHS, Expr.mul(
Expr.sub(Expr.reshape(xtildeR.slice([0, k], [Nb, k + 1]), 1, Nb), gI), 0.5)),
Expr.mul(Expr.sub(gR, Expr.reshape(xtildeI.slice([0, k], [Nb, k + 1]), 1, Nb)), 0.5))
initialModel.constraint(Expr.hstack(chiBarLHS, chiBarRHS), Domain.inQCone())
try:
initialModel.solve()
xtilde = np.reshape(xtildeR.level() + 1j * xtildeI.level(), (Nb, K + Nr))
theta = thetaR.level() + 1j * thetaI.level()
solFlag = 1
initialModel.dispose()
return solFlag, xtilde, theta
except OptimizeError as e:
print("优化失败。错误: {0}".format(e))
return 0, np.zeros((Nb, K + Nr), dtype=complex), np.zeros(Ns, dtype=complex)
except SolutionError:
# 未获取到预期状态的解，尝试诊断原因
print("请求的解不可用。")
prob_status = initialModel.getProblemStatus()
if prob_status == ProblemStatus.DualInfeasible:
print("找到对偶不可行性证明。")
elif prob_status == ProblemStatus.PrimalInfeasible:
print("找到原始不可行性证明。")
elif prob_status == ProblemStatus.Unknown:
# 解状态未知，终止代码指示优化器提前终止的原因
print("解状态未知。")
else:
print("得到其他意外的问题状态 {0}。".format(prosta))
return 0, np.zeros((Nb, K + Nr), dtype=complex), np.zeros(Ns, dtype=complex)
except Exception as e:
print("意外错误: {0}".format(e))
return 0, np.zeros((Nb, K + Nr), dtype=complex), np.zeros(Ns, dtype=complex)
# ============== 计算第一组常数的函数
def computeParameterSet1(Nb, K, Nr, gCurrent, xTildeCurrent):
aCurrent = np.squeeze(gCurrent[None, :] @ xTildeCurrent)
bCurrent = np.tile(aCurrent, (Nb, 1)) * np.tile(gCurrent.conj()[:, None], (1, K + Nr)) + xTildeCurrent
aR = aCurrent.real
aI = aCurrent.imag
aAbsSQ = abs(aCurrent) ** 2
bCurrentR = bCurrent.real
bCurrentI = bCurrent.imag
bCurrentNormSQ = np.linalg.norm(bCurrent, axis=0) ** 2 # 按列2-范数
delta1 = bCurrentR.T * aR[:, None] + bCurrentI.T * aI[:, None]
delta2 = bCurrentR.T * aI[:, None] - bCurrentI.T * aR[:, None]
return aCurrent, aAbsSQ, bCurrentR, bCurrentI, bCurrentNormSQ, delta1, delta2
# ============== 计算第二组常数的函数
def computeParameterSet2(Nb, K, hCurrent, xTildeCurrent):
cCurrent = np.diag(hCurrent @ xTildeCurrent[:, 0:K])
dCurrent = np.tile(cCurrent, (Nb, 1)) * Herm(hCurrent) + xTildeCurrent[:, 0:K]
cR = cCurrent.real
cI = cCurrent.imag
cAbsSQ = abs(cCurrent) ** 2
dCurrentR = dCurrent.real
dCurrentI = dCurrent.imag
dCurrentNormSQ = np.linalg.norm(dCurrent, axis=0) ** 2 # 按列2-范数
delta3 = dCurrentR.T * cR[:, None] + dCurrentI.T * cI[:, None]
delta4 = dCurrentR.T * cI[:, None] - dCurrentI.T * cR[:, None]
return cCurrent, cAbsSQ, dCurrentR, dCurrentI, dCurrentNormSQ, delta3, delta4
# ============== 计算第二组常数的函数
def ComputeParametersSet3(k, K, Nr, hCurrent, xTildeCurrent):
# ------------ (10)的常数值 ------------
Lambda = np.real(np.tile(hCurrent[[k], :], (K + Nr - 1, 1))) - np.real(xTildeCurrent[:, np.arange(K + Nr) != k].T)
LambdaTilde = np.imag(np.tile(hCurrent[[k], :], (K + Nr - 1, 1))) + np.imag(
xTildeCurrent[:, np.arange(K + Nr) != k].T)
normCSQ = np.reshape(np.linalg.norm(np.tile(Herm(hCurrent[[k], :]), (1, K + Nr - 1))
- xTildeCurrent[:, np.arange(K + Nr) != k], axis=0) ** 2, (-1, 1))
# ------------ (11)的常数值 ------------
eta = np.real(np.tile(hCurrent[[k], :], (K + Nr - 1, 1))) + np.real(xTildeCurrent[:, np.arange(K + Nr) != k].T)
etaTilde = np.imag(np.tile(hCurrent[[k], :], (K + Nr - 1, 1))) - np.imag(xTildeCurrent[:, np.arange(K + Nr) != k].T)
normDSQ = np.reshape(np.linalg.norm(np.tile(Herm(hCurrent[[k], :]), (1, K + Nr - 1))
+ xTildeCurrent[:, np.arange(K + Nr) != k], axis=0) ** 2, (-1, 1))
# ------------ (13)的常数值 ------------
psi = np.real(np.tile(hCurrent[[k], :], (K + Nr - 1, 1))) - np.imag(xTildeCurrent[:, np.arange(K + Nr) != k].T)
psiTilde = np.imag(np.tile(hCurrent[[k], :], (K + Nr - 1, 1))) - np.real(xTildeCurrent[:, np.arange(K + Nr) != k].T)
normESQ = np.reshape(np.linalg.norm(np.tile(Herm(hCurrent[[k], :]), (1, K + Nr - 1))
+ 1j * xTildeCurrent[:, np.arange(K + Nr) != k], axis=0) ** 2, (-1, 1))
# ------------ (14)的常数值 ------------
phi = np.real(np.tile(hCurrent[[k], :], (K + Nr - 1, 1))) + np.imag(xTildeCurrent[:, np.arange(K + Nr) != k].T)
phiTilde = np.imag(np.tile(hCurrent[[k], :], (K + Nr - 1, 1))) + np.real(xTildeCurrent[:, np.arange(K + Nr) != k].T)
normFSQ = np.reshape(np.linalg.norm(np.tile(Herm(hCurrent[[k], :]), (1, K + Nr - 1))
- 1j * xTildeCurrent[:, np.arange(K + Nr) != k], axis=0) ** 2, (-1, 1))
return Lambda, LambdaTilde, normCSQ, eta, etaTilde, normDSQ, psi, psiTilde, normESQ, phi, phiTilde, normFSQ
def computeParameterSet4(k, gCurrent, xTildeCurrent):
eta1 = np.real(gCurrent) - np.real(xTildeCurrent[:, k])
eta2 = np.imag(gCurrent) + np.imag(xTildeCurrent[:, k])
etaNormSQ = np.linalg.norm(Herm(gCurrent) - xTildeCurrent[:, k]) ** 2
etaBar1 = np.real(gCurrent) + np.real(xTildeCurrent[:, k])
etaBar2 = np.imag(gCurrent) - np.imag(xTildeCurrent[:, k])
etaBarNormSQ = np.linalg.norm(Herm(gCurrent) + xTildeCurrent[:, k]) ** 2
chi1 = np.real(gCurrent) - np.imag(xTildeCurrent[:, k])
chi2 = np.imag(gCurrent) - np.real(xTildeCurrent[:, k])
chiNormSQ = np.linalg.norm(Herm(gCurrent) + 1j * xTildeCurrent[:, k]) ** 2
chiBar1 = np.real(gCurrent) + np.imag(xTildeCurrent[:, k])
chiBar2 = np.imag(gCurrent) + np.real(xTildeCurrent[:, k])
chiBarNormSQ = np.linalg.norm(Herm(gCurrent) - 1j * xTildeCurrent[:, k]) ** 2
return eta1, eta2, etaBar1, etaBar2, chi1, chi2, chiBar1, chiBar2, etaNormSQ, etaBarNormSQ, chiNormSQ, chiBarNormSQ
# 检查约束满足状态
def constraint_status(arg, channels, xTilde, thetaVec):
localFlag = 1
# 解包参数
Nb, K, Nr, Ns, Pmax, gamma, gammaR, zeta = arg.Nb, arg.K, arg.Q, arg.Ns, arg.Pmax, arg.gamma, arg.gammaR, arg.zeta
# 解包信道
G, hD, hRelayed, gRelayed, scaledNoisePower, sf = channels
hCurrent = hD + hRelayed @ np.diag(thetaVec) @ G
gCurrent = gRelayed @ np.diag(thetaVec) @ G
sinrNumC = abs(np.diag(hCurrent @ xTilde[:, 0:K])) ** 2
sinrDenC = scaledNoisePower + np.sum(abs(np.einsum('ij,jk->ik', hCurrent, xTilde)) ** 2, 1) - sinrNumC
sinrNumR = abs(gCurrent @ (xTilde[:, 0:K])) ** 2
sinrDenR = (scaledNoisePower +
np.sum(abs(np.einsum('ij,jk->ik', gCurrent[None, :], xTilde)) ** 2, 1) - sinrNumR)
sinrC = sinrNumC / sinrDenC
sinrR = sinrNumR / sinrDenR
for k in range(K):
localFlag = localFlag and (sinrC[k] >= gamma)
localFlag = localFlag and (sinrR[k] <= gammaR)
localFlag = localFlag and (np.linalg.norm(xTilde, 'fro') ** 2 <= Pmax)
return not localFlag
# 寻找初始点的函数
def find_initial_points(arg, channels):
xTildeCurrent = np.ones((arg.Nb, arg.K + arg.Q)) + 1j * np.ones((arg.Nb, arg.K + arg.Q))
thetaVecCurrent = np.ones(arg.Ns)
constraint_flag = 1
breakFlag = 1
iIter = 0
print("正在寻找初始解", end='')
while (constraint_flag == 1) and (iIter < 50):
sys.stdout.write('\r正在寻找初始解 ' + next(cursor_symbols))
sys.stdout.flush()
solFlag, xTildeCurrent, thetaVecCurrent = SCA_feasible(arg, channels, xTildeCurrent, thetaVecCurrent)
if solFlag == 1:
constraint_flag = constraint_status(arg, channels, xTildeCurrent, thetaVecCurrent)
breakFlag = 0
else:
breakFlag = 1
break
iIter += 1
return breakFlag, xTildeCurrent, thetaVecCurrent4. 结论
本文针对RIS辅助的保密ISAC系统，研究了基于SCA的联合波束成形优化算法。通过构造目标函数的凹下界、对SINR和泄漏约束进行二阶锥转换，以及引入正则化项处理恒模约束，成功将原非凸问题转化为一系列可高效求解的SOCP子问题。与传统的惩罚式AO算法相比，所提SCA算法具有以下突出优点：
- 解质量高：所有变量同步优化，避免了AO中的次优陷阱，。
- 可行性保障：每次迭代均产生可行解，支持提前终止。
- 未来工作可进一步考虑不完美信道状态信息下的鲁棒设计，以及多目标扩展场景。
复现代码可见VX公众号，所见即所得
参考文献
1 M. Hua, Q. Wu, W. Chen, O. A. Dobre, and A. L. Swindlehurst, "Secure
intelligent reflecting surface aided integrated sensing and communication," arXiv preprint arXiv:2207.09095, 2022.
2 SCA-Based Beamforming Optimization for IRS-Enabled Secure Integrated Sensing and Communication 2023 IEEE Global Communications Conference: Communication & Information Systems Security