• 为了保证你在浏览本网站时有着更好的体验,建议使用类似Chrome、Firefox之类的浏览器~~
    • 如果你喜欢本站的内容何不Ctrl+D收藏一下呢,与大家一起分享各种编程知识~
    • 本网站研究机器学习、计算机视觉、模式识别~当然不局限于此,生命在于折腾,何不年轻时多折腾一下

rbm受限波兹曼算法理解

Alg admin 9个月前 (03-23) 575次浏览 0个评论 扫描二维码

本文主要是参考了http://blog.echen.me/2011/07/18/introduction-to-restricted-boltzmann-machines/ 这篇文章,这个文章从二分因子的角度去理解,真的是讲得清新脱俗。

背景:假设你要求一群用户从 0-100 分来给一组电影打分。在经典的因子分析中,你可以尝试依据一组隐藏因子来解释每部电影及用户。例如,像星球大战和指环王这类电影与“科幻小说和魔幻”这类隐藏因子可能强相关,而喜欢瓦力和玩具总动员的用户与“皮克斯动画工作室”这一隐藏因子可能强相关。

从到这的分析可以大致看出,我们需要是发现背后的因子与当前我们实际观察的数据之间的关系。

RBM 可以理解为一种二值化的因子分析法(这是对它的一种理解方式,当然还有其他的理解方式及用途,原文作者主要采用二值化因子分析法去解释并实现)。与以往让用户采用一个连续的分数段为电影打分不同的是,这里只是告诉你他们“喜欢”还是“不喜欢”一部电影(1 或 0),之后 RBM 将会尝试找到之所以这样去选择电影的隐藏因子。

例如,假设我们有一组共六部电影(哈利·波特、阿凡达、指环王 3、角斗士、泰坦尼克号和星梦泪痕)并且让用户告诉我们他们想看哪些。如果我们想学到两个隐藏单元潜在的电影偏好—比如,在我们六部电影里呈现出了两个自然分组:“科幻小说/魔幻”组(包括哈利·波特、阿凡达和指环王 3)以及“奥斯卡获得者”组(包括指环王、角斗士和泰坦尼克号),所以我们可能希望我们的隐藏单元将会与这些分组相对应—那么,RBM 可能看起来像这样:

假设我们的两个隐藏单元确实与“科幻小说/魔幻”及“奥斯卡获得者”相对应。

  • 如果 Alice 告诉我们她关于六部电影的二进制偏好值(可视层),我们就可以去问我们的 RBM:与她偏好相对应的哪个隐藏单元会被激活(1 或 0)(如:要求 RBM 依据隐藏因子去解释她的偏好)。所以可视层的六部电影向隐藏单元发送消息,以更新隐藏层。(注意:即使 Alice 已经声称她想看哈利·波特、阿凡达和指环王 3,也不能保证代表“科幻小说/魔幻”的隐藏层会被置 1,但是只有那样才会有很大的可能性被置 1。这也说得通:在现实世界中,因为 Alice 想看这三部电影通常使我们非常确信她喜欢“科幻小说/魔幻”类型的,但是,还是有可能因为其他原因使她做出这样的选择。因此,RBM 允许我们在这个混乱真实的世界为人生成模型)
  • 反过来,如果我们知道某人喜欢“科幻小说/魔幻”(此时“科幻小说/魔幻”隐藏单元被置 1),我们便可以要求这个隐藏单元置 1 的电影单元 RBM(比如,要求它生成一组电影推荐)。所以,隐藏单元向电影单元(可视层)发消息,告诉他们去更新他们的状态。(请再次注意,“科幻小说/魔幻”单元被置 1 不能保证我们总会推荐这三部电影:哈利·波特、阿凡达和指环王 3。因为,你想想,并不是每个喜欢科幻小说的人都喜欢阿凡达)

上面举得这个例子相对来说比较简单,其实在推荐系统中的用户比这个复杂一些,也就是用户的兴趣会点亮多个隐层,也就是反映用户兴趣的多样性。

RBM 的运作方式

可视层的神经元用\(x_i\)表示,隐藏层神经元用\(x_j\)表示,它们之间的权重用\(w_ij\)表示,可视层神经元个数为 m,隐藏层神经元个数为 n。当给定可视层状态后,用下式更新隐藏层的状态。

\begin{equation}net_j=\sum_{i=0}^m{x_i{w_{ij}}}\end{equation}

\(x_0\)是偏置单元,总为 1

\begin{equation}prob(j)=sigmoid(net_j)=\frac{1}{1+e^{-net_j}}\end{equation}
\(x_j\)以概率 prob(j)取 1,以概率 1−prob(j)取 0。

sigmoid 函数关于(0,0.5)这一点中心对称,x 为正时 sigmoid(x)>0.5,x→∞时 sigmoid(x)→1。

根据隐藏层求可视层方式雷同,就不写公式了。

对于推荐系统来说,我们知道用户购买了哪些商品,将对应的可视层神经元置为 1,其他置为 0,求出隐藏层状态,由隐藏层再返回来求可视层状态,这个时候可视层哪些神经元为 1 我们就把相应有商品推荐给用户。

权重学习方法

训练 RBM 网络就是训练权重\(w_{ij}\)。首先随机初始化\(w_{ij}\),然后每一次拿一个样本(即可视层是已知的)经历下面的步骤。

由可视层的\(x_i\)算出隐藏层的\(x_j\),令\(w_{ij}\)的正向梯度为
$$positive(wij)=xi∗xj$$
由隐藏层\(x_j\)再来反向计算\(x′_i\),注意此时算出的\(x′_i\)跟原先的\(x_i\)已经不一样了,令\(w_{ij}\)的负向梯度为
$$negative(wij)=x′i∗xj$$
更新权重
$$w_{ij}=w_{ij}+α∗(positive(w_{ij})−negative(w_{ij}))$$
我们不去深究为什么正向梯度和负向梯度是这样一个公式。上述学习方式叫对比散度(contrastive divergence)法。

循环拿样本去训练网络,不停迭代,直到收敛(即\(x′_i\)和\(x_i\)很接近)。

 

首先,我使用一些造的数据来训练 RBM:

  • Alice: (Harry Potter = 1, Avatar = 1, LOTR 3 = 1, Gladiator = 0, Titanic = 0, Glitter = 0). Big SF/fantasy fan(科幻超级迷妹).
  • Bob: (Harry Potter = 1, Avatar = 0, LOTR 3 = 1, Gladiator = 0, Titanic = 0, Glitter = 0). SF/fantasy fan, but doesn’t like Avatar(科幻迷,但不喜欢阿凡达).
  • Carol: (Harry Potter = 1, Avatar = 1, LOTR 3 = 1, Gladiator = 0, Titanic = 0, Glitter = 0). Big SF/fantasy fan(科幻超级迷).
  • David: (Harry Potter = 0, Avatar = 0, LOTR 3 = 1, Gladiator = 1, Titanic = 1, Glitter = 0). Big Oscar winners fan(奥斯卡超级迷).
  • Eric: (Harry Potter = 0, Avatar = 0, LOTR 3 = 1, Gladiator = 1, Titanic = 0, Glitter = 0). Oscar winners fan, except for Titanic(奥斯卡迷,但不喜欢泰坦尼克号(译者注:原文此处 Titanic = 1 有误)).
  • Fred: (Harry Potter = 0, Avatar = 0, LOTR 3 = 1, Gladiator = 1, Titanic = 1, Glitter = 0). Big Oscar winners fan(奥斯卡超级迷).

该网络学习到了以下权重:

请注意,第一个隐藏单元看起来对应“奥斯卡获得者”,第二个隐藏单元看起来对应“科幻小说/魔幻”,跟我们预期一致。
如果给 RBM 一个新的用户输入会发生什么呢?(可视层到隐藏层)比如 George, 他的偏好是(Harry Potter = 0, Avatar = 0, LOTR 3 = 0, Gladiator = 1, Titanic = 1, Glitter = 0) ,结果是“奥斯卡获得者”对应的隐藏单元被置 1(而不是“科幻小说/魔幻”),正确地猜出乔治可能更喜欢“奥斯卡获得者”类型的电影。
如果我们只激活“科幻小说/魔幻”对应的单元,并且让 RBM 训练一段时间会发生什么呢?(隐藏层到可视层)在我的试验中,有三次哈利·波特、阿凡达和指环王 3 被置 1;有一次阿凡达和指环王 3 被置 1,而哈利波特没有;有两次,哈利·波特和指环王 3 被置 1,而阿凡达没有。注意,给予我们的训练集,这些生成的偏好的确匹配了我们觉得真正的科幻迷想要看的电影。

代码实践

 

# -*- coding: utf-8 -*-
# @Time    : 2019/3/22 下午 5:07
# @Author  : zhusimaji
# @File    : rbm.py
# @Software: PyCharm

import numpy as np


class RBM(object):

    def __init__(self, num_visible, num_hidden, learn_rate=0.1, learn_batch=1000):
        self.num_visible = num_visible  # 可视层神经元个数
        self.num_hidden = num_hidden  # 隐藏层神经元个数
        self.learn_rate = learn_rate  # 学习率
        self.learn_batch = learn_batch  # 每次根据多少样本进行学习

        '''初始化连接权重'''
        self.weights = 0.1 * \
                       np.random.randn(self.num_visible,
                                       self.num_hidden)  # 依据 0.1 倍的标准正太分布随机生成权重
        # 第一行插入全 0,即偏置和隐藏层的权重初始化为 0
        self.weights = np.insert(self.weights, 0, 0, axis=0)
        # 第一列插入全 0,即偏置和可视层的权重初始化为 0
        self.weights = np.insert(self.weights, 0, 0, axis=1)

    def _logistic(self, x):
        '''直接使用 1.0 / (1.0 + np.exp(-x))容易发警告“RuntimeWarning: overflowencountered in exp”,
           转换成如下等价形式后算法会更稳定
        '''
        return 0.5 * (1 + np.tanh(0.5 * x))

    def train(self, rating_data, max_steps=1000, eps=1.0e-4):
        '''迭代训练,得到连接权重
        '''
        for step in range(max_steps):  # 迭代训练多少次
            error = 0.0  # 误差平方和
            # 每次拿一批样本还调整权重
            for i in range(0, rating_data.shape[0], self.learn_batch):
                num_examples = min(self.learn_batch, rating_data.shape[0] - i)
                data = rating_data[i:i + num_examples, :]
                data = np.insert(data, 0, 1, axis=1)  # 第一列插入全 1,即偏置的值初始化为 1

                pos_hidden_activations = np.dot(data, self.weights)
                pos_hidden_probs = self._logistic(pos_hidden_activations)
                pos_hidden_states = pos_hidden_probs > np.random.rand(
                    num_examples, self.num_hidden + 1)
                # pos_associations=np.dot(data.T,pos_hidden_states)         #对隐藏层作二值化
                pos_associations = np.dot(
                    data.T, pos_hidden_probs)  # 对隐藏层不作二值化

                neg_visible_activations = np.dot(
                    pos_hidden_states, self.weights.T)
                neg_visible_probs = self._logistic(neg_visible_activations)
                neg_visible_probs[:, 0] = 1  # 强行把偏置的值重置为 1
                neg_hidden_activations = np.dot(
                    neg_visible_probs, self.weights)
                neg_hidden_probs = self._logistic(neg_hidden_activations)
                # neg_hidden_states=neg_hidden_probs>np.random.rand(num_examples,self.num_hidden+1)
                # neg_associations=np.dot(neg_visible_probs.T,neg_hidden_states)      #对隐藏层作二值化
                neg_associations = np.dot(
                    neg_visible_probs.T, neg_hidden_probs)  # 对隐藏层不作二值化

                # 更新权重。另外一种尝试是带冲量的梯度下降,即本次前进的方向是本次梯度与上一次梯度的线性加权和(这样的话需要额外保存上一次的梯度)
                self.weights += self.learn_rate * \
                                (pos_associations - neg_associations) / num_examples

                # 计算误差平方和
                error += np.sum((data - neg_visible_probs) ** 2)
            if error < eps: # 所有样本的误差平方和低于阈值于终止迭代 break print('iteration %d, error is %f' % (step, error)) def getHidden(self, visible_data): '''根据输入层得到隐藏层 visible_data 是一个 matrix,每行代表一个样本 ''' num_examples = visible_data.shape[0] hidden_states = np.ones((num_examples, self.num_hidden + 1)) visible_data = np.insert(visible_data, 0, 1, axis=1) # 第一列插入偏置 hidden_activations = np.dot(visible_data, self.weights) hidden_probs = self._logistic(hidden_activations) hidden_states[:, :] = hidden_probs > np.random.rand(
            num_examples, self.num_hidden + 1)
        hidden_states = hidden_states[:, 1:]  # 即首列删掉,即把偏置去掉
        return hidden_states

    def getVisible(self, hidden_data):
        '''根据隐藏层得到输入层
           hidden_data 是一个 matrix,每行代表一个样本
        '''
        num_examples = hidden_data.shape[0]
        visible_states = np.ones((num_examples, self.num_visible + 1))
        hidden_data = np.insert(hidden_data, 0, 1, axis=1)
        visible_activations = np.dot(hidden_data, self.weights.T)
        visible_probs = self._logistic(visible_activations)
        visible_states[:, :] = visible_probs > np.random.rand(
            num_examples, self.num_visible + 1)
        visible_states = visible_states[:, 1:]
        return visible_states

    def predict(self, visible_data):
        num_examples = visible_data.shape[0]
        hidden_states = np.ones((num_examples, self.num_hidden + 1))
        visible_data = np.insert(visible_data, 0, 1, axis=1)  # 第一列插入偏置
        '''forward'''
        hidden_activations = np.dot(visible_data, self.weights)
        hidden_probs = self._logistic(hidden_activations)
        # hidden_states[:, :] = hidden_probs > np.random.rand(
        #     num_examples, self.num_hidden + 1)
        '''backward'''
        visible_states = np.ones((num_examples, self.num_visible + 1))
        # visible_activations = np.dot(hidden_states, self.weights.T)  #对隐藏层作二值化
        visible_activations = np.dot(hidden_probs, self.weights.T)  # 对隐藏层不作二值化
        visible_probs = self._logistic(visible_activations)  # 直接返回可视层的概率值

        return visible_probs[:, 1:]  # 把第 0 列(偏置)去掉


if __name__ == '__main__':
    rbm = RBM(num_visible=6, num_hidden=2, learn_rate=0.1, learn_batch=1000)
    rating_data = np.array([[1, 1, 1, 0, 0, 0], [1, 0, 1, 0, 0, 0], [1, 1, 1, 0, 0, 0], [
        0, 0, 1, 1, 1, 0], [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0]])
    rbm.train(rating_data, max_steps=500, eps=1.0e-4)
    print('weight:\n', rbm.weights)
    rating = np.array([[0, 0, 0, 0.9, 0.7, 0]])  # 评分需要做归一化。该用户喜欢第四、五项
    hidden_data = rbm.getHidden(rating)
    print('hidden_data:\n', hidden_data)
    visible_data = rbm.getVisible(hidden_data)
    print('visible_data:\n', visible_data)
    predict_data = rbm.predict(rating)
    print('推荐得分:')
    for i, score in enumerate(predict_data[0, :]):
        print(i, score)  # 第三、四、五项的推荐得分很高,同时用户已明确表示过喜欢四、五,所以我们把第三项推荐给用户

参考资料

http://www.cnblogs.com/zhangchaoyang/articles/5537643.html
https://blog.csdn.net/doleria/article/details/78618022


Deeplearn, 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权 , 转载请注明rbm 受限波兹曼算法理解
喜欢 (0)
admin
关于作者:
互联网行业码农一枚/业余铲屎官/数码影音爱好者/二次元

您必须 登录 才能发表评论!