2024年诺贝尔物理学奖: 他们利用物理学来设计Hopfield网络和玻尔兹曼机

import numpy as npimport matplotlib.pyplot as plt
def image_to_vector(image):    vector = image.flatten()    vector = np.where(vector == 0, -1, 1)    return vector
def vector_to_image(vector, shape):    image = np.where(vector == -1, 0, 1)    return image.reshape(shape)
def train_hopfield(patterns):    num_neurons = patterns[0].size    W = np.zeros((num_neurons, num_neurons))    for p in patterns:        W += np.outer(p, p)    np.fill_diagonal(W, 0)    return W / num_neurons
def energy(state, W):    return -0.5 * np.dot(state, np.dot(W, state))
def update_state(state, W):    new_state = state.copy()    for i in range(len(state)):        h = np.dot(W[i], new_state)        s = 1 if h >= 0 else -1        # 检查能量是否降低        original_energy = energy(new_state, W)        new_state[i] = s        new_energy = energy(new_state, W)        if new_energy > original_energy:            new_state[i] = state[i]    return new_state
def run_hopfield(initial_state, W, max_steps=100):    state = initial_state.copy()    for _ in range(max_steps):        new_state = update_state(state, W)        if np.array_equal(new_state, state):            break        state = new_state    return state
# 原始图像pattern = np.array([    [1, 0, 1],    [0, 1, 0],    [1, 0, 1]])
# 训练网络vector_pattern = image_to_vector(pattern)patterns = [vector_pattern]W = train_hopfield(patterns)
# 有噪声的输入noisy_pattern = np.array([    [1, 1, 1],    [0, 0, 0],    [1, 1, 1]])vector_noisy = image_to_vector(noisy_pattern)
# 恢复图像recovered_vector = run_hopfield(vector_noisy, W)recovered_image = vector_to_image(recovered_vector, pattern.shape)
# 显示图像fig, axs = plt.subplots(1, 3, figsize=(9, 3))
axs[0].imshow(pattern, cmap='gray')axs[0].set_title('原始图像')axs[0].axis('off')
axs[1].imshow(noisy_pattern, cmap='gray')axs[1].set_title('有噪声的图像')axs[1].axis('off')
axs[2].imshow(recovered_image, cmap='gray')axs[2].set_title('恢复的图像')axs[2].axis('off')
plt.show()

import numpy as np
class RBM:    def __init__(self, n_visible, n_hidden, learning_rate=0.1):        self.n_visible = n_visible  # 可见层节点数        self.n_hidden = n_hidden    # 隐藏层节点数        self.learning_rate = learning_rate
        # 初始化权重和偏置        self.weights = np.random.normal(0, 0.01, size=(self.n_visible, self.n_hidden))        self.visible_bias = np.zeros(self.n_visible)        self.hidden_bias = np.zeros(self.n_hidden)
    def sigmoid(self, x):        return 1.0 / (1 + np.exp(-x))
    def train(self, data, epochs=1000):        """        使用对比散度（Contrastive Divergence，CD）算法训练RBM        """        num_samples = data.shape[0]
        for epoch in range(epochs):            # 正相位：从数据计算隐藏层概率            pos_hidden_probs = self.sigmoid(np.dot(data, self.weights) + self.hidden_bias)            pos_hidden_states = (pos_hidden_probs > np.random.rand(num_samples, self.n_hidden)).astype(float)            pos_associations = np.dot(data.T, pos_hidden_probs)
            # 负相位：从隐藏层重构可见层，再计算隐藏层            neg_visible_probs = self.sigmoid(np.dot(pos_hidden_states, self.weights.T) + self.visible_bias)            neg_hidden_probs = self.sigmoid(np.dot(neg_visible_probs, self.weights) + self.hidden_bias)            neg_associations = np.dot(neg_visible_probs.T, neg_hidden_probs)
            # 更新权重和偏置            self.weights += self.learning_rate * (pos_associations - neg_associations) / num_samples            self.visible_bias += self.learning_rate * np.mean(data - neg_visible_probs, axis=0)            self.hidden_bias += self.learning_rate * np.mean(pos_hidden_probs - neg_hidden_probs, axis=0)
            # 可选：计算重构误差            if epoch % 100 == 0:                error = np.mean((data - neg_visible_probs) ** 2)                print(f"Epoch {epoch}: Reconstruction error = {error}")
    def run_visible(self, data):        """        给定可见层输入，计算隐藏层的激活概率        """        hidden_probs = self.sigmoid(np.dot(data, self.weights) + self.hidden_bias)        return hidden_probs
    def run_hidden(self, data):        """        给定隐藏层输入，计算可见层的激活概率        """        visible_probs = self.sigmoid(np.dot(data, self.weights.T) + self.visible_bias)        return visible_probs
    def sample_hidden(self, visible):        """        从可见层采样隐藏层状态        """        hidden_probs = self.run_visible(visible)        hidden_states = (hidden_probs > np.random.rand(self.n_hidden)).astype(float)        return hidden_states
    def sample_visible(self, hidden):        """        从隐藏层采样可见层状态        """        visible_probs = self.run_hidden(hidden)        visible_states = (visible_probs > np.random.rand(self.n_visible)).astype(float)        return visible_states
    def generate(self, n_samples, n_steps=1000):        """        从随机初始化开始，生成新样本        """        samples = []        visible = (np.random.rand(self.n_visible) > 0.5).astype(float)
        for _ in range(n_samples):            for _ in range(n_steps):                hidden = self.sample_hidden(visible)                visible = self.sample_visible(hidden)            samples.append(visible.copy())
        return np.array(samples)
# 示例数据：简单的二进制模式data = np.array([    [1, 1, 0, 0],  # 模式A    [1, 0, 1, 0],  # 模式B    [1, 0, 0, 1],  # 模式C    [0, 1, 1, 0],  # 模式D    [0, 1, 0, 1],  # 模式E    [0, 0, 1, 1],  # 模式F])
# 创建RBM实例rbm = RBM(n_visible=4, n_hidden=2, learning_rate=0.1)
# 训练RBMrbm.train(data, epochs=1000)
# 从训练好的RBM中生成新样本generated_samples = rbm.generate(n_samples=5, n_steps=500)print("Generated samples:")print(generated_samples)