常见克隆数分配#

将种群按亲和度从高到低排序，选取前 $n$ 个进行克隆。第 $i$ 名的克隆数可设为

其中 $\beta$ 为克隆因子。

超变异（Hypermutation）强度#

变异强度与亲和度负相关。对归一化亲和度 $\widehat{\text{Aff}}\in[0,1]$，一种常用设定：

然后对实数编码做高斯扰动：

对二进制编码可用按位翻转概率 $p_i = p_{\max}\exp(-\rho\,\widehat{\text{Aff}}(a_i))$。

伪代码#

Input: population size N, selected n, clone factor β, refresh rate r
Initialize P with N random antibodies
Initialize memory M = ∅
repeat
  Evaluate Aff(a) for a in P
  Update memory M with best antibodies from P ∪ M
  Select top-n antibodies S from P
  C = ∅
  for i-th antibody in S (ranked):
	  clone n_i copies -> add to C
  Hypermutate all clones in C (mutation inversely to affinity)
  Evaluate Aff for clones; keep best clones to form P'
  Suppress highly similar antibodies in P' (keep diversity)
  Refresh: replace worst ⌊rN⌋ in P' with random antibodies
  P = P'
until stop criterion
Output: best antibody in M

Python 示例：用 CLONALG 优化 Rastrigin（连续最小化）#

下面代码演示一个“可跑通”的最小实现：亲和度用 $\exp(-\gamma f(x))$，并做简单的相似度抑制与刷新。

import numpy as np


def rastrigin(x: np.ndarray) -> float:
	# global minimum at x=0, f=0
	A = 10.0
	return A * x.size + np.sum(x * x - A * np.cos(2 * np.pi * x))


def clonalg_optimize(
	f,
	dim: int,
	bounds: tuple[float, float] = (-5.12, 5.12),
	N: int = 60,
	n_select: int = 12,
	beta: float = 6.0,
	sigma_max: float = 0.8,
	rho: float = 4.0,
	gamma: float = 0.08,
	refresh_rate: float = 0.15,
	suppress_delta: float = 0.25,
	iters: int = 200,
	seed: int = 0,
):
	rng = np.random.default_rng(seed)
	lo, hi = bounds

	def clip(x):
		return np.clip(x, lo, hi)

	# population: (N, dim)
	P = rng.uniform(lo, hi, size=(N, dim))
	best_x = None
	best_f = np.inf

	for _ in range(iters):
		fvals = np.array([f(x) for x in P])
		idx = np.argsort(fvals)  # minimization
		P = P[idx]
		fvals = fvals[idx]

		if fvals[0] < best_f:
			best_f = float(fvals[0])
			best_x = P[0].copy()

		# affinity in [0,1], larger is better
		aff = np.exp(-gamma * fvals)
		aff_norm = (aff - aff.min()) / (aff.max() - aff.min() + 1e-12)

		S = P[:n_select]
		S_aff = aff_norm[:n_select]

		# cloning
		clones = []
		for i, (x, a) in enumerate(zip(S, S_aff), start=1):
			n_i = int(np.floor(beta * n_select / i))
			if n_i <= 0:
				continue
			# hypermutation strength: high affinity -> small sigma
			sigma = sigma_max * np.exp(-rho * a)
			noise = rng.normal(0.0, sigma, size=(n_i, dim))
			clones.append(clip(x + noise))

		C = np.vstack(clones) if clones else clip(rng.uniform(lo, hi, size=(N, dim)))
		C_f = np.array([f(x) for x in C])
		# pick best N candidates from union
		U = np.vstack([P, C])
		U_f = np.concatenate([fvals, C_f])
		U_idx = np.argsort(U_f)
		P_new = U[U_idx][:N]

		# simple suppression: remove too-close individuals (euclidean)
		kept = []
		for x in P_new:
			if not kept:
				kept.append(x)
				continue
			dmin = min(np.linalg.norm(x - y) for y in kept)
			if dmin >= suppress_delta:
				kept.append(x)
			if len(kept) >= N:
				break
		# refill if suppressed too much
		while len(kept) < N:
			kept.append(rng.uniform(lo, hi, size=(dim,)))
		P = np.array(kept)

		# refresh worst
		k = int(np.floor(refresh_rate * N))
		if k > 0:
			P[-k:] = rng.uniform(lo, hi, size=(k, dim))

	return best_x, best_f


if __name__ == "__main__":
	x_star, f_star = clonalg_optimize(rastrigin, dim=10, iters=300, seed=42)
	print("best f:", f_star)
	print("best x (first 5 dims):", x_star[:5])

基本定义（以二进制串为例）#

自体集合 $\mathcal{S}$（正常样本），探测器集合 $\mathcal{D}$。匹配规则通常基于海明距离：

其中 $r$ 为匹配半径。

伪代码#

Input: self set S, detector count M, radius r
Initialize D = ∅
while |D| < M:
  sample random candidate d
  if ∀s∈S: d_H(d,s) > r:
	  add d to D
Detect(x): if ∃d∈D with d_H(d,x) ≤ r then anomaly else normal

NSA 的难点是“覆盖率 vs 误报率”的权衡：$r$ 大则覆盖强但误报高；$r$ 小则漏报风险大。