受限波兹曼机导论Introduction to Restricted Boltzmann Machines

Suppose you ask a bunch of users to rate a set of movies on a 0-100 scale. In classical factor analysis, you could then try to explain each movie and user in terms of a set of latent factors. For example, movies like Star Wars and Lord of the Rings might have strong associations with a latent science fiction and fantasy factor, and users who like Wall-E and Toy Story might have strong associations with a latent Pixar factor.

Restricted Boltzmann Machines essentially perform a binary version of factor analysis. (This is one way of thinking about RBMs; there are, of course, others, and lots of different ways to use RBMs, but I’ll adopt this approach for this post.) Instead of users rating a set of movies on a continuous scale, they simply tell you whether they like a movie or not, and the RBM will try to discover latent factors that can explain the activation of these movie choices.

More technically, a Restricted Boltzmann Machine is a stochastic neural network (neural network meaning we have neuron-like units whose binary activations depend on the neighbors they’re connected to; stochastic meaning these activations have a probabilistic element) consisting of:

  • One layer of visible units (users’ movie preferences whose states we know and set);
  • One layer of hidden units (the latent factors we try to learn); and
  • A bias unit (whose state is always on, and is a way of adjusting for the different inherent popularities of each movie).

Furthermore, each visible unit is connected to all the hidden units (this connection is undirected, so each hidden unit is also connected to all the visible units), and the bias unit is connected to all the visible units and all the hidden units. To make learning easier, we restrict the network so that no visible unit is connected to any other visible unit and no hidden unit is connected to any other hidden unit.

For example, suppose we have a set of six movies (Harry Potter, Avatar, LOTR 3, Gladiator, Titanic, and Glitter) and we ask users to tell us which ones they want to watch. If we want to learn two latent units underlying movie preferences – for example, two natural groups in our set of six movies appear to be SF/fantasy (containing Harry Potter, Avatar, and LOTR 3) and Oscar winners (containing LOTR 3, Gladiator, and Titanic), so we might hope that our latent units will correspond to these categories – then our RBM would look like the following:

(Note the resemblance to a factor analysis graphical model.)

State Activation

Restricted Boltzmann Machines, and neural networks in general, work by updating the states of some neurons given the states of others, so let’s talk about how the states of individual units change. Assuming we know the connection weights in our RBM (we’ll explain how to learn these below), to update the state of unit ii:

  • Compute the activation energy a_i=∑_jw_ijx_ja_i=∑_jw_ijx_j of unit ii, where the sum runs over all units jj that unit ii is connected to, w_ijw_ij is the weight of the connection between ii and jj, and x_jx_j is the 0 or 1 state of unit jj. In other words, all of unit ii’s neighbors send it a message, and we compute the sum of all these messages.
  • Let p_i=σ(a_i)p_i=σ(a_i), where σ(x)=1/(1+exp(−x))σ(x)=1/(1+exp(−x)) is the logistic function. Note that p_ip_i is close to 1 for large positive activation energies, and p_ip_i is close to 0 for negative activation energies.
  • We then turn unit ii on with probability p_ip_i, and turn it off with probability 1−p_i1−p_i.
  • (In layman’s terms, units that are positively connected to each other try to get each other to share the same state (i.e., be both on or off), while units that are negatively connected to each other are enemies that prefer to be in different states.)

For example, let’s suppose our two hidden units really do correspond to SF/fantasy and Oscar winners.

  • If Alice has told us her six binary preferences on our set of movies, we could then ask our RBM which of the hidden units her preferences activate (i.e., ask the RBM to explain her preferences in terms of latent factors). So the six movies send messages to the hidden units, telling them to update themselves. (Note that even if Alice has declared she wants to watch Harry Potter, Avatar, and LOTR 3, this doesn’t guarantee that the SF/fantasy hidden unit will turn on, but only that it will turn on with highprobability. This makes a bit of sense: in the real world, Alice wanting to watch all three of those movies makes us highly suspect she likes SF/fantasy in general, but there’s a small chance she wants to watch them for other reasons. Thus, the RBM allows us to generate models of people in the messy, real world.)
  • Conversely, if we know that one person likes SF/fantasy (so that the SF/fantasy unit is on), we can then ask the RBM which of the movie units that hidden unit turns on (i.e., ask the RBM to generate a set of movie recommendations). So the hidden units send messages to the movie units, telling them to update their states. (Again, note that the SF/fantasy unit being on doesn’t guarantee that we’ll always recommend all three of Harry Potter, Avatar, and LOTR 3 because, hey, not everyone who likes science fiction liked Avatar.)

Learning Weights

So how do we learn the connection weights in our network? Suppose we have a bunch of training examples, where each training example is a binary vector with six elements corresponding to a user’s movie preferences. Then for each epoch, do the following:

  • Take a training example (a set of six movie preferences). Set the states of the visible units to these preferences.
  • Next, update the states of the hidden units using the logistic activation rule described above: for the jjth hidden unit, compute its activation energy a_j=∑_iw_ijx_ia_j=∑_iw_ijx_i, and set x_jx_j to 1 with probability σ(a_j)σ(a_j) and to 0 with probability 1−σ(a_j)1−σ(a_j). Then for each edge e_ije_ij, compute Positive(e_ij)=x_i\*x_jPositive(e_ij)=x_i\*x_j (i.e., for each pair of units, measure whether they’re both on).
  • Now reconstruct the visible units in a similar manner: for each visible unit, compute its activation energy a_ia_i, and update its state. (Note that this reconstruction may not match the original preferences.) Then update the hidden units again, and computeNegative(e_ij)=x_i\*x_jNegative(e_ij)=x_i\*x_j for each edge.
  • Update the weight of each edge e_ije_ij by setting w_ij=w_ij+L\*(Positive(e_ij)−Negative(e_ij))w_ij=w_ij+L\*(Positive(e_ij)−Negative(e_ij)), where LL is a learning rate.
  • Repeat over all training examples.

Continue until the network converges (i.e., the error between the training examples and their reconstructions falls below some threshold) or we reach some maximum number of epochs.

Why does this update rule make sense? Note that

  • In the first phase, Positive(e_ij)Positive(e_ij) measures the association between the iith and jjth unit that we want the network to learn from our training examples;
  • In the “reconstruction” phase, where the RBM generates the states of visible units based on its hypotheses about the hidden units alone, Negative(e_ij)Negative(e_ij) measures the association that the network itself generates (or “daydreams” about) when no units are fixed to training data.

So by adding Positive(e_ij)−Negative(e_ij)Positive(e_ij)−Negative(e_ij) to each edge weight, we’re helping the network’s daydreams better match the reality of our training examples.

(You may hear this update rule called contrastive divergence, which is basically a funky term for “approximate gradient descent”.)

Examples

I wrote a simple RBM implementation in Python (the code is heavily commented, so take a look if you’re still a little fuzzy on how everything works), so let’s use it to walk through some examples.

First, I trained the RBM using some fake data.

  • 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 = 1, Glitter = 0). Oscar winners fan, except for Titanic.
  • Fred: (Harry Potter = 0, Avatar = 0, LOTR 3 = 1, Gladiator = 1, Titanic = 1, Glitter = 0). Big Oscar winners fan.

The network learned the following weights:

                 Bias Unit       Hidden 1        Hidden 2
  Bias Unit       -0.08257658     -0.19041546      1.57007782
  Harry Potter    -0.82602559     -7.08986885      4.96606654
  Avatar          -1.84023877     -5.18354129      2.27197472
  LOTR 3           3.92321075      2.51720193      4.11061383
  Gladiator        0.10316995      6.74833901     -4.00505343
  Titanic         -0.97646029      3.25474524     -5.59606865
  Glitter         -4.44685751     -2.81563804     -2.91540988
  

Note that the first hidden unit seems to correspond to the Oscar winners, and the second hidden unit seems to correspond to the SF/fantasy movies, just as we were hoping.

What happens if we give the RBM a new user, George, who has (Harry Potter = 0, Avatar = 0, LOTR 3 = 0, Gladiator = 1, Titanic = 1, Glitter = 0) as his preferences? It turns the Oscar winners unit on (but not the SF/fantasy unit), correctly guessing that George probably likes movies that are Oscar winners.

What happens if we activate only the SF/fantasy unit, and run the RBM a bunch of different times? In my trials, it turned on Harry Potter, Avatar, and LOTR 3 three times; it turned on Avatar and LOTR 3, but not Harry Potter, once; and it turned on Harry Potter and LOTR 3, but not Avatar, twice. Note that, based on our training examples, these generated preferences do indeed match what we might expect real SF/fantasy fans want to watch.

Modifications

I tried to keep the connection-learning algorithm I described above pretty simple, so here are some modifications that often appear in practice:

  • Above, Negative(e_ij)Negative(e_ij) was determined by taking the product of the iith and jjth units after reconstructing the visible unitsonce and then updating the hidden units again. We could also take the product after some larger number of reconstructions (i.e., repeat updating the visible units, then the hidden units, then the visible units again, and so on); this is slower, but describes the network’s daydreams more accurately.
  • Instead of using Positive(e_ij)=x_i\*x_jPositive(e_ij)=x_i\*x_j, where x_ix_i and x_jx_j are binary 0 or 1 states, we could also let x_ix_i and/or x_jx_j be activation probabilities. Similarly for Negative(e_ij)Negative(e_ij).
  • We could penalize larger edge weights, in order to get a sparser or more regularized model.
  • When updating edge weights, we could use a momentum factor: we would add to each edge a weighted sum of the current step as described above (i.e., L\*(Positive(e_ij)−Negative(e_ij)L\*(Positive(e_ij)−Negative(e_ij)) and the step previously taken.
  • Instead of using only one training example in each epoch, we could use batches of examples in each epoch, and only update the network’s weights after passing through all the examples in the batch. This can speed up the learning by taking advantage of fast matrix-multiplication algorithms.

Further

If you’re interested in learning more about Restricted Boltzmann Machines, here are some good links.

from: http://blog.echen.me/2011/07/18/introduction-to-restricted-boltzmann-machines/

时间: 2024-10-08 13:58:50

受限波兹曼机导论Introduction to Restricted Boltzmann Machines的相关文章

受限波尔茨曼机

受限波尔茨曼机(RBM)是一种可以在输入数据集上学习概率分布的生成的随机神经网络.由隐含层,可见层,偏置层组成.可见层与隐含层无方向性,可以相互传播.每个当前层的神经元与下一层的每个神经元都有连接. 算法主要想法是正向过程中影响了网络内部对于真实数据的表示.同时,反向过程尝试通过这个被影响过的表示方法重建数据.主要目的是可以可以使生成的数据与原数据尽可能相似,这个差异影响权重更新.这样的网络具感知对输入数据表示的程度的能力,而且通过这个能力重建数据.辛顿提出一种叫做对比散度(contrastiv

限制Boltzmann机(Restricted Boltzmann Machine)

限制Boltzmann机(Restricted Boltzmann Machine) 起源:Boltzmann神经网络 Boltzmann神经网络的结构是由Hopfield递归神经网络改良过来的,Hopfield中引入了统计物理学的能量函数的概念. 即,cost函数由统计物理学的能量函数给出,随着网络的训练,能量函数会逐渐变小. 可视为一动力系统,其能量函数的极小值对应系统的稳定平衡点. Hinton发明的Boltzmann中乘热打铁,对神经元输出引入了随机概率重构的概念.其想法来自于模拟退火算

受限玻尔兹曼机(Restricted Boltzmann Machine)

受限玻尔兹曼机(Restricted Boltzmann Machine) 作者:凯鲁嘎吉 - 博客园 http://www.cnblogs.com/kailugaji/ 1. 生成模型 2. 参数学习 3. 对比散度学习算法 由于受限玻尔兹曼机的特殊结构,因此可以使用一种比吉布斯采样更有效 的学习算法,即对比散度(Contrastive Divergence)对比散度算法仅需k步吉布斯采样.为了提高效率,对比散度算法用一个训练样本作为可观测向量的初始值.然后,交替对可观测向量和隐藏向量进行吉布

课程学习 - 人类疾病导论 | Introduction To Human Disease

完美人类假设:一类人,具有最完美的基因组,享受最健康的环境和饮食,同时拥有最健康的思想情绪,最终以最长的寿命,自然死亡. 自然死亡是自然生命最终的归宿,这是写在目前基因组里的铁律! 不管科技如何发展,人最终都会追求生命的拓展和延续,所以医学总体是不可能败落的,只是医学的部分低价值的工作会被淘汰. 疾病的研究似乎永远没有尽头,疾病本质就是健康的异常,鉴于健康的生命活动的复杂性,任何一个局部发生异常都会导致疾病. 所以,生命系统有多复杂,疾病研究就能有多复杂! 有趣的是,必须通过疾病模型,我们才能更

OpenCV Tutorials —— Introduction to Support Vector Machines

支持向量机 ~~   How is the optimal hyperplane computed? Let's introduce the notation used to define formally a hyperplane: where is known as the weight vector and as the bias.   The optimal hyperplane can be represented in an infinite number of different

受限玻尔兹曼机(Restricted Boltzmann Machine,RBM)代码1

环境:python 2, 32位 https://www.cnblogs.com/tuhooo/p/5440473.html 备注:这个python代码需要用到psyco包,psyco包目前只有python2 32位版本.在windows 64+python 3环境下,如果下载psyco的源代码安装,比较麻烦. https://blog.csdn.net/qq_36965134/article/details/80039026 """ Continuous Restricte

文献 | 2010-2016年被引用次数最多的深度学习论文(修订版)

本来来自 :http://blog.csdn.net/u010402786/article/details/51682917 一.书籍 Deep learning (2015) 作者:Bengio 下载地址:http://www.deeplearningbook.org/ 二.理论 1.在神经网络中提取知识 Distilling the knowledge in a neural network 作者:G. Hinton et al. 2.深度神经网络很易受骗:高信度预测无法识别的图片 Deep

详细解读神经网络十大误解,再也不会弄错它的工作原理

来源:http://www.cstor.cn/textdetail_10544.html_biz=MjM5OTA1MDUyMA==&mid=407358558&idx=2&sn=b21877f23bf4063fa311185009c1f0b7&scene=0#wechat_redirect1462674382044 神经网络是机器学习算法中最流行和最强大的一类.但在作者看来,因为人们对神经网络工作原理存在误解,导致网络设计也很糟糕.所以这篇文章就对其中一些误解进行了讨论.

机器学习术语表

FFNN Feed Forward Neural Network 前馈神经网络,神经网络中一般输入向前传递 BP Backpropagation 反向传播,一般专指误差反向传播算法, RBM Restricted Boltzmann Machine 限制波兹曼机 受限波兹曼机 监督学习 给出data与label 无监督学习 仅有data 强化学习 给出data与响应函数,让机器根据响应函数反馈自行学习 深度学习 一般指神经网络这样拥有深层结构的算法 自博弈学习 一对生成算法和判别算法互相学习,最