受限玻尔兹曼机(Restricted Boltzmann Machine, RBM)是一种基于能量模型的神经网络模型，在Hinton提出针对其的训练算法(对比分歧算法)后，RBM得到了更多的关注，利用RBM的堆叠可以构造出深层的神经网络模型——深度信念网(Deep Belief Net, DBN)。下面简单介绍二值型RBM的主要内容。

一、RBM的网络结构

RBM的网络结构如下图所示：

RBM中包括两层，即：

可见层(visible layer)，图上的vmathbf{v}
隐藏层(hidden layer)，图上的hmathbf{h}

由上图可知，在同一层中，如上图中的可见层，在可见层中，其节点之间是没有连接的，而在层与层之间，其节点是全连接的，这是RBM最重要的结构特征：层内无连接，层间全连接。

在RBM的模型中，有如下的性质：

当给定可见层神经元的状态时。各隐藏层神经元的之间是否激活是条件独立的；反之也同样成立。

下面给出RBM模型的数学化定义：

如图：

(图片来自参考文献1)

二、RBM模型的计算

2.1、能量函数

2.2、激活概率

2.3、模型的训练

2.3.1、模型的优化函数

2.3.2、最大似然的求解

2.3.3、优化求解

三、实验

实验代码

# coding:UTF-8

import numpy as np
import random as rd

def load_data(file_name):
    data = []
    f = open(file_name)
    for line in f.readlines():
        lines = line.strip().split("	")
        tmp = []
        for x in lines:
            tmp.append(float(x) / 255.0)
        data.append(tmp)
    f.close()
    return data

def sigmrnd(P):
    m, n = np.shape(P)
    X = np.mat(np.zeros((m, n)))
    P_1 = sigm(P)
    for i in xrange(m):
        for j in xrange(n):
            r = rd.random()
            if P_1[i, j] >= r:
                X[i, j] = 1

    return X

def sigm(P):
    return 1.0 / (1 + np.exp(-P))         


# step_1: load data    
datafile = "b.txt"
data = np.mat(load_data(datafile))
m, n = np.shape(data)

# step_2: initialize
num_epochs = 10
batch_size = 100
input_dim = n

hidden_sz = 100

alpha = 1
momentum = 0.1
W = np.mat(np.zeros((hidden_sz, input_dim)))
vW = np.mat(np.zeros((hidden_sz, input_dim)))
b = np.mat(np.zeros((input_dim, 1)))
vb = np.mat(np.zeros((input_dim, 1)))
c = np.mat(np.zeros((hidden_sz, 1)))
vc = np.mat(np.zeros((hidden_sz, 1)))

# step_3: training
print "Start to train RBM: "

num_batches = int(m / batch_size)
for i in xrange(num_epochs):
    kk = np.random.permutation(range(m))
    err = 0.0

    for j in xrange(num_batches):
        batch = data[kk[j * batch_size:(j + 1) * batch_size], ]

    v1 = batch
        h1 = sigmrnd(np.ones((batch_size, 1)) * c.T + v1 * W.T)
        v2 = sigmrnd(np.ones((batch_size, 1)) * b.T + h1 * W)
        h2 = sigm(np.ones((batch_size, 1)) * c.T + v2 * W.T)

        c1 = h1.T * v1
        c2 = h2.T * v2

        vW = momentum * vW + alpha * (c1 - c2) / batch_size
        vb = momentum * vb + alpha * sum(v1 - v2).T / batch_size
        vc = momentum * vc + alpha * sum(h1 - h2).T / batch_size

        W = W + vW
        b = b + vb
        c = c + vc

    #cal_err
    err_result = v1 - v2
        err_1 = 0.0
    m_1, n_1 = np.shape(err_result)
    for x in xrange(m_1):
            for y in xrange(n_1):
            err_1 = err_1 + err_result[x, y] ** 2

        err = err + err_1 / batch_size
    #print i,j,err

    print i, err / num_batches

#print W

m_2,n_2 = np.shape(W)

for i in xrange(m_2):
    for j in xrange(n_2):
        print str(W[i, j]) + " ",
    print "
",

参考文献

优质内容筛选与推荐>>
1、架构组织形式的讨论，以及架构师之路的建议
2、想开店跟我去摸底
3、手把手教你做QQ狂人DIY版
4、open-cv template matching
5、记录OPENGL学习中遇到的问题