当前位置：首页 > news >正文

从烽火台到5G：用Python代码模拟信道模型，理解信息传输的极限

news 2026/6/12 1:42:18

从烽火台到5G：用Python代码模拟信道模型，理解信息传输的极限

通信技术的演进史，本质上是一部人类突破信息传输极限的奋斗史。从烽火台的狼烟到摩尔斯电码的滴答声，从模拟电话的电流波动到5G网络的毫米波，每一种通信方式都面临着同一个核心问题：如何在存在噪声和干扰的环境中，可靠地传递尽可能多的信息。这正是信息论中"信道容量"概念试图回答的问题。

对于现代开发者和技术爱好者而言，理解信道模型不必停留在数学公式的推导上。借助Python生态中的NumPy、Matplotlib等工具，我们可以通过代码模拟不同信道的行为，直观感受信息传输的瓶颈所在。本文将带您穿越时空，用Python重建从古代到现代的几个典型通信场景，通过实验揭示信道容量的实际意义。

1. 信道模型基础与Python实现框架

在开始历史之旅前，我们需要建立统一的代码框架。信道模型的核心是转移概率矩阵，它定义了输入符号被转换为输出符号的概率分布。

import numpy as np from collections import defaultdict import matplotlib.pyplot as plt class DiscreteChannel: def __init__(self, transition_matrix, input_labels, output_labels): """ 离散信道类 :param transition_matrix: 转移概率矩阵，形状为(input_size, output_size) :param input_labels: 输入符号标签列表 :param output_labels: 输出符号标签列表 """ self.transition_matrix = np.array(transition_matrix) self.input_labels = input_labels self.output_labels = output_labels assert len(input_labels) == self.transition_matrix.shape[0] assert len(output_labels) == self.transition_matrix.shape[1] def transmit(self, input_symbol): """模拟单个符号的传输过程""" input_idx = self.input_labels.index(input_symbol) probs = self.transition_matrix[input_idx] output_idx = np.random.choice(len(self.output_labels), p=probs) return self.output_labels[output_idx] def batch_transmit(self, input_sequence): """模拟符号序列的传输""" return [self.transmit(symbol) for symbol in input_sequence]

这个基础类将作为我们所有实验的起点。接下来，我们将实现几个关键函数来计算信道容量：

def entropy(prob_dist): """计算概率分布的熵""" probs = np.array(prob_dist) return -np.sum(probs * np.log2(probs + 1e-10)) # 加小量避免log(0) def mutual_information(channel, input_dist): """ 计算给定输入分布下的互信息 :param channel: DiscreteChannel实例 :param input_dist: 输入符号的概率分布，与channel.input_labels顺序一致 """ # 计算联合概率P(x,y) = P(x)P(y|x) joint_probs = np.outer(input_dist, channel.transition_matrix) # 计算输出分布P(y) output_probs = np.sum(joint_probs, axis=0) # 计算H(Y) hy = entropy(output_probs) # 计算H(Y|X) hy_x = np.sum([p_x * entropy(p_y_given_x) for p_x, p_y_given_x in zip(input_dist, channel.transition_matrix)]) return hy - hy_x def channel_capacity(channel, tolerance=1e-5, max_iter=1000): """通过迭代优化计算信道容量""" n_inputs = len(channel.input_labels) # 初始化为均匀分布 current_dist = np.ones(n_inputs) / n_inputs prev_capacity = 0 for _ in range(max_iter): # 计算当前互信息 current_mi = mutual_information(channel, current_dist) # 更新输入分布 joint_probs = np.outer(current_dist, channel.transition_matrix) output_probs = np.sum(joint_probs, axis=0) conditional_probs = joint_probs / (output_probs + 1e-10) new_dist = current_dist * np.exp( np.sum(channel.transition_matrix * np.log(conditional_probs + 1e-10), axis=1)) new_dist /= np.sum(new_dist) # 检查收敛 if abs(current_mi - prev_capacity) < tolerance: break prev_capacity = current_mi current_dist = new_dist return prev_capacity, current_dist

2. 古代通信系统的信道模拟

2.1 烽火台：最早的二元通信系统

烽火台是古代最简单的数字通信系统之一，其信道模型可以用二元对称信道(BSC)来描述。假设：

输入符号：["点火"，"不点火"]
输出符号：["看到火"，"没看到火"]
转移概率矩阵：[[0.9, 0.1], [0.1, 0.9]]（正确识别概率90%）

# 烽火台信道模型 beacon_channel = DiscreteChannel( transition_matrix=[[0.9, 0.1], [0.1, 0.9]], input_labels=["点火", "不点火"], output_labels=["看到火", "没看到火"] ) # 模拟传输过程 input_signal = ["点火"]*5 + ["不点火"]*5 # 交替发送信号 output_signal = beacon_channel.batch_transmit(input_signal) print(f"输入信号: {input_signal}") print(f"输出信号: {output_signal}") # 计算信道容量 capacity, opt_dist = channel_capacity(beacon_channel) print(f"烽火台信道容量: {capacity:.3f} bits/符号") print(f"最优输入分布: {dict(zip(beacon_channel.input_labels, opt_dist))}")

烽火台信道特点分析：

信道容量约为0.531 bits/符号
最优输入分布接近均匀分布（点火概率50%）
误码主要来自天气干扰和观察误差
信息传输速率极低，需要预先约定的编码方案

2.2 旗语与鼓声：多元离散信道

与烽火台相比，旗语和鼓声系统能够传递更丰富的信息。以旗语为例：

# 旗语信道模型（简化版，三种旗语位置） semaphore_channel = DiscreteChannel( transition_matrix=[ [0.7, 0.2, 0.1], # 位置1 [0.1, 0.8, 0.1], # 位置2 [0.1, 0.2, 0.7] # 位置3 ], input_labels=["位置1", "位置2", "位置3"], output_labels=["位置1", "位置2", "位置3"] ) # 可视化传输误差 def visualize_errors(channel, n_samples=1000): confusion = defaultdict(int) for inp in channel.input_labels: for _ in range(n_samples): out = channel.transmit(inp) confusion[(inp, out)] += 1 # 绘制混淆矩阵 fig, ax = plt.subplots() mat = np.zeros((len(channel.input_labels), len(channel.output_labels))) for i, inp in enumerate(channel.input_labels): for j, out in enumerate(channel.output_labels): mat[i,j] = confusion[(inp, out)] / n_samples cax = ax.matshow(mat, cmap='Blues') fig.colorbar(cax) ax.set_xticks(range(len(channel.output_labels))) ax.set_yticks(range(len(channel.input_labels))) ax.set_xticklabels(channel.output_labels) ax.set_yticklabels(channel.input_labels) ax.set_xlabel('接收符号') ax.set_ylabel('发送符号') plt.title('信道混淆矩阵') plt.show() visualize_errors(semaphore_channel)

古代通信系统的局限性：

信道容量受限于物理媒介（可见度、声音传播距离）
误码率高，需要冗余编码
信息传输速率低（每分钟几个符号）
依赖训练有素的操作人员

3. 近代通信：电报与早期数字通信

3.1 摩尔斯电码的二元信道

电报系统引入了更规范的数字通信方式。摩尔斯电码本质上是一种二元编码系统：

# 电报信道模型（考虑线路噪声） telegraph_channel = DiscreteChannel( transition_matrix=[ [0.85, 0.15], # 点→点/误为划 [0.15, 0.85] # 划→划/误为点 ], input_labels=["点", "划"], output_labels=["点", "划"] ) # 摩尔斯编码表示字母 morse_code = { 'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.', 'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.', 'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-', 'V': '...-', 'W': '.--', 'X': '-..-', 'Y': '-.--', 'Z': '--..' } def encode_text(text, code_dict): """文本编码为摩尔斯电码序列""" return ' '.join([code_dict[c] for c in text.upper() if c in code_dict]) def simulate_telegraph(text, channel): """模拟电报传输过程""" encoded = encode_text(text, morse_code) print(f"原始编码: {encoded}") transmitted = [] for symbol in encoded: if symbol == ' ': transmitted.append(' ') else: transmitted.append(channel.transmit(symbol)) received = ''.join(transmitted) print(f"接收信号: {received}") return received # 模拟传输短句 sample_text = "hello world" simulate_telegraph(sample_text, telegraph_channel)

电报系统的进步与挑战：

首次实现了快速远距离通信（相比烽火台）
引入了标准化的编码方案
信道噪声主要来自线路质量和操作误差
需要复杂的错误检测和纠正机制

3.2 信道容量的实际意义

通过实验我们可以直观理解信道容量的含义：

# 研究不同误码率下的信道容量 error_rates = np.linspace(0, 0.5, 50) capacities = [] for err in error_rates: channel = DiscreteChannel( transition_matrix=[[1-err, err], [err, 1-err]], input_labels=["0", "1"], output_labels=["0", "1"] ) capacity, _ = channel_capacity(channel) capacities.append(capacity) plt.plot(error_rates, capacities) plt.xlabel('误码率') plt.ylabel('信道容量 (bits/符号)') plt.title('BSC信道容量与误码率关系') plt.grid(True) plt.show()

这个实验清晰地展示了香农极限的存在——当误码率达到50%时，信道容量降为零，通信变得不可能。

4. 现代数字通信：从电话到5G

4.1 移动通信中的衰落信道模型

现代无线通信面临更复杂的信道特性，特别是多径衰落现象。我们可以用Python模拟这种场景：

def simulate_fading_channel(input_signal, snr_db=20, doppler_shift=0): """ 模拟瑞利衰落信道 :param input_signal: 输入信号数组（复数形式） :param snr_db: 信噪比(dB) :param doppler_shift: 多普勒频移(Hz) :return: 接收信号 """ n = len(input_signal) # 瑞利衰落系数（时变） t = np.arange(n) h = (np.random.randn() + 1j*np.random.randn()) * np.exp(1j*2*np.pi*doppler_shift*t/n) # 加性高斯白噪声 snr_linear = 10**(snr_db/10) noise_power = 1/snr_linear noise = np.sqrt(noise_power/2) * (np.random.randn(n) + 1j*np.random.randn()) return h * input_signal + noise # 生成QPSK信号 n_symbols = 1000 symbols = np.random.choice([1+1j, 1-1j, -1+1j, -1-1j], n_symbols) received = simulate_fading_channel(symbols, snr_db=15, doppler_shift=5) # 可视化 plt.figure(figsize=(10,5)) plt.subplot(1,2,1) plt.scatter(np.real(symbols), np.imag(symbols), alpha=0.3) plt.title('发送信号星座图') plt.xlabel('I'); plt.ylabel('Q') plt.subplot(1,2,2) plt.scatter(np.real(received), np.imag(received), alpha=0.3) plt.title('接收信号星座图') plt.xlabel('I'); plt.ylabel('Q') plt.tight_layout() plt.show()

现代通信的关键技术：

正交频分复用(OFDM)对抗多径效应
多天线系统(MIMO)提高信道容量
自适应调制编码(AMC)适应信道变化
强大的纠错编码(LDPC、Polar码)

4.2 5G信道模型仿真

5G新空口(NR)引入了毫米波频段，带来了新的信道特性：

def simulate_5g_channel(input_signal, frequency=28e9, speed=3, snr_db=20): """ 简化版5G毫米波信道模拟 :param frequency: 载波频率(Hz) :param speed: 移动速度(m/s) :param snr_db: 信噪比(dB) """ c = 3e8 # 光速 wavelength = c / frequency doppler_shift = speed / wavelength # 毫米波信道通常有更少但更强的多径分量 n_paths = 3 delays = np.random.randint(0, 20, n_paths) # 时延采样点 gains = np.abs(np.random.randn(n_paths) + 1j*np.random.randn(n_paths)) gains /= np.sum(gains) # 归一化功率 output = np.zeros_like(input_signal, dtype=complex) for i in range(n_paths): shifted = np.roll(input_signal, delays[i]) output += gains[i] * shifted * np.exp(1j*2*np.pi*doppler_shift*np.arange(len(input_signal))/len(input_signal)) # 添加噪声 snr_linear = 10**(snr_db/10) noise_power = 1/snr_linear noise = np.sqrt(noise_power/2) * (np.random.randn(len(input_signal)) + 1j*np.random.randn(len(input_signal))) return output + noise # 测试不同移动速度下的性能 speeds = [0, 3, 10, 30] # m/s ber = [] # 误码率 for speed in speeds: errors = 0 trials = 1000 for _ in range(trials): tx_signal = np.random.choice([1+1j, 1-1j, -1+1j, -1-1j]) rx_signal = simulate_5g_channel(np.array([tx_signal]), speed=speed) decision = 1+1j if np.real(rx_signal[0]) > 0 and np.imag(rx_signal[0]) > 0 else \ 1-1j if np.real(rx_signal[0]) > 0 and np.imag(rx_signal[0]) <= 0 else \ -1+1j if np.real(rx_signal[0]) <= 0 and np.imag(rx_signal[0]) > 0 else -1-1j if decision != tx_signal: errors += 1 ber.append(errors / trials) plt.plot(speeds, ber, marker='o') plt.xlabel('移动速度 (m/s)') plt.ylabel('误码率') plt.title('5G毫米波信道误码率与移动速度关系') plt.grid(True) plt.show()

5G通信的关键改进：

更高的频段带来更大带宽（提高信道容量）
大规模MIMO技术（空间复用增益）
波束成形技术（对抗路径损耗）
灵活帧结构（适应不同业务需求）

5. 信道编码：突破容量极限的艺术

5.1 从汉明码到LDPC码

信道编码是逼近信道容量的关键技术。我们可以实现简单的汉明码(7,4)来演示其原理：

# (7,4)汉明码实现 G = np.array([ # 生成矩阵 [1, 0, 0, 0, 1, 1, 0], [0, 1, 0, 0, 1, 0, 1], [0, 0, 1, 0, 0, 1, 1], [0, 0, 0, 1, 1, 1, 1] ]) H = np.array([ # 校验矩阵 [1, 1, 0, 1, 1, 0, 0], [1, 0, 1, 1, 0, 1, 0], [0, 1, 1, 1, 0, 0, 1] ]) def hamming_encode(data): """编码4位数据为7位汉明码""" assert len(data) == 4 return np.mod(np.dot(data, G), 2) def hamming_decode(received): """解码并纠正单比特错误""" syndrome = np.mod(np.dot(H, received), 2) error_pos = int(''.join(map(str, syndrome[::-1])), 2) - 1 if error_pos >= 0: received[error_pos] ^= 1 # 纠正错误 return received[:4] # 返回原始数据位 # 测试编码解码过程 data = np.array([1, 0, 1, 1]) encoded = hamming_encode(data) print(f"原始数据: {data}") print(f"编码后: {encoded}") # 模拟信道错误 error_pos = 2 received = encoded.copy() received[error_pos] ^= 1 print(f"接收信号(含错误): {received}") decoded = hamming_decode(received) print(f"解码结果: {decoded}")

5.2 现代编码技术的性能比较

我们可以模拟比较不同编码方案的性能：

def simulate_coding_performance(coding_func, decoding_func, snr_range, trials=1000): """模拟不同SNR下的编码性能""" ber = [] for snr_db in snr_range: errors = 0 bits_sent = 0 for _ in range(trials): # 生成随机数据 data = np.random.randint(0, 2, 4) encoded = coding_func(data) # 模拟BSC信道 received = [] for bit in encoded: p_error = 10**(-snr_db/10) if np.random.rand() < p_error: received.append(1 - bit) else: received.append(bit) # 解码并统计错误 decoded = decoding_func(np.array(received)) errors += np.sum(data != decoded) bits_sent += len(data) ber.append(errors / bits_sent) return ber # 比较不同编码方案 snr_range = np.arange(0, 10, 0.5) ber_uncoded = [] ber_hamming = [] for snr_db in snr_range: # 未编码性能 errors = 0 for _ in range(1000): bit = np.random.randint(0, 2) p_error = 10**(-snr_db/10) if np.random.rand() < p_error: errors += 1 ber_uncoded.append(errors / 1000) # 汉明码性能 ber_hamming.append(simulate_coding_performance( hamming_encode, lambda r: hamming_decode(r)[:4], [snr_db] )[0]) plt.semilogy(snr_range, ber_uncoded, label='未编码') plt.semilogy(snr_range, ber_hamming, label='汉明码(7,4)') plt.xlabel('SNR (dB)') plt.ylabel('误码率') plt.title('编码与未编码系统性能比较') plt.legend() plt.grid(True) plt.show()

现代编码技术的发展趋势：