忍者ブログ

Memeplexes

プログラミング、3DCGとその他いろいろについて

かんたん!制限付きボルツマンマシン GPUで実装 実数(0から1)バージョン (C#) [Deep Learningシリーズ]

制限付きボルツマンマシンをGPUで動かす

Deep Learningに使うことがある、制限(制約)付きボルツマンマシン(Restricted Boltzmann Machine : RBM)をまた実装してみました。
ただし今度はGPUで動きます。
といってもあまり考えずにプログラムしたのでGPGPUにしては遅い気がします。
パフォーマンスチューニングはこれからして行きましょう。


拍手[1回]

PR

かんたん!制限付きボルツマンマシン実装 実数バージョン (C#)訂正 [Deep Learningシリーズ]

可視層の状態をランダムに

以前、このような記事を書いたのですが、こっちのほうが正しいような気がしてきました。
しかし性能はどちらがいいかは…。

思い出しっぷりはこちらのほうが悪いですが、可視層もランダムにしようと思ったらこうなるでしょうね。

ちなみにこいつで画像を扱うと、結果がざらつくようです。
あんまり使いたくないですね。

RestrictedBoltzmannMachine.cs

using System;
using System.Threading.Tasks;

namespace RestrictedBoltzmannMachines.RealValue
{
    public class RestrictedBoltzmannMachine
    {
        public SymmetricConnection[][] Connections;
        public VisibleNeuron[] VisibleNeurons;
        public HiddenNeuron[] HiddenNeurons;

        public RestrictedBoltzmannMachine(int visibleNeuronCount, int hiddenNeuronCount, Random random) :
            this(SymmetricConnection.CreateRandomWeights(random, visibleNeuronCount, hiddenNeuronCount), new double[visibleNeuronCount], new double[hiddenNeuronCount], random)
        {
        }

        public RestrictedBoltzmannMachine(double[][] weights, double[] visibleBiases, double[] hiddenBiases, Random random)
        {
            this.VisibleNeurons = Neuron.CreateNeurons<VisibleNeuron>(visibleBiases);
            this.HiddenNeurons = Neuron.CreateNeurons<HiddenNeuron>(hiddenBiases);
            this.Connections = SymmetricConnection.CreateConnections(weights, VisibleNeurons, HiddenNeurons);
            Neuron.WireConnections(this.Connections);

            foreach (var neuron in this.VisibleNeurons)
            {
                neuron.Random = new Random(random.Next());
            }

            foreach (var neuron in this.HiddenNeurons)
            {
                neuron.Random = new Random(random.Next());
            }
        }

        public void SetVisibleNeuronValues(double[] visibleValues)
        {
            for (int i = 0; i < this.VisibleNeurons.Length; i++)
            {
                this.VisibleNeurons[i].Value = visibleValues[i];
            }
        }

        public void LearnFromData(double learningRate, int freeAssociationStepCount = 1)
        {
            Wake(learningRate);
            Sleep(learningRate, freeAssociationStepCount);
            EndLearning();
        }

        public void Wake(double learningRate)
        {
            UpdateHiddenNeurons();
            learn(learningRate);
        }

        public void UpdateVisibleNeurons()
        {
            updateNeurons(this.VisibleNeurons);
        }

        public void UpdateHiddenNeurons()
        {
            updateNeurons(this.HiddenNeurons);
        }

        private void updateNeurons(Neuron[] neurons)
        {
            Parallel.ForEach(neurons, neuron => neuron.Update());
        }


        private void learn(double learningRate)
        {
            Parallel.ForEach(Connections, connectionRow =>
            {
                foreach (var connection in connectionRow)
                {
                    connection.Learn(learningRate);
                }
            });

            Parallel.ForEach(VisibleNeurons, neuron => neuron.Learn(learningRate));
            Parallel.ForEach(HiddenNeurons, neuron => neuron.Learn(learningRate));
        }

        public void Sleep(double learningRate, int freeAssociationStepCount)
        {
            doFreeAssociation(freeAssociationStepCount);
            learn(-learningRate);
        }

        //Gibbs sampling
        private void doFreeAssociation(int freeAssociationStepCount)
        {
            for (int step = 0; step < freeAssociationStepCount; step++)
            {
                UpdateVisibleNeurons();
                UpdateHiddenNeurons();
            }
        }

        public void EndLearning()
        {
            Parallel.ForEach(Connections, connectionRow =>
            {
                foreach (var connection in connectionRow)
                {
                    connection.EndLearning();
                }
            });

            Parallel.ForEach(VisibleNeurons, neuron => neuron.EndLearning());
            Parallel.ForEach(HiddenNeurons, neuron => neuron.EndLearning());
        }

        public void Associate()
        {
            UpdateHiddenNeurons();
            UpdateVisibleNeurons();
        }
    }
}

Neuron.cs

using System;
using System.Collections.Generic;

namespace RestrictedBoltzmannMachines.RealValue
{
    public abstract class Neuron
    {
        public double Value;
        public double Bias;
        public double DeltaBias;
        public List<Synapse> Synapses = new List<Synapse>();
        public Random Random;

        public abstract void Update();
        public abstract void Learn(double learningRate);

        public void EndLearning()
        {
            this.Bias += this.DeltaBias;
            this.DeltaBias = 0;
        }

        public static T[] CreateNeurons<T>(double[] biases)
            where T : Neuron, new() 
        {
            T[] result = new T[biases.Length];

            for (int i = 0; i < result.Length; i++)
            {
                result[i] = new T { Bias = biases[i] };
            }

            return result;
        }

        public static void WireConnections(SymmetricConnection[][] connections)
        {
            foreach (var connectionRow in connections)
            {
                foreach (var connection in connectionRow)
                {
                    Synapse hiddenConnection = new Synapse();
                    hiddenConnection.Connection = connection;
                    hiddenConnection.SourceNeuron = connection.VisibleNeuron;
                    connection.HiddenNeuron.Synapses.Add(hiddenConnection);

                    Synapse visibleConnection = new Synapse();
                    visibleConnection.Connection = connection;
                    visibleConnection.SourceNeuron = connection.HiddenNeuron;
                    connection.VisibleNeuron.Synapses.Add(visibleConnection);
                }
            }
        }

        protected double GetInputFromSourceNeurons()
        {
            double result = 0;

            for (int i = 0; i < Synapses.Count; i++)
            {
                var s = Synapses[i];
                result += s.Connection.Weight * s.SourceNeuron.Value;
            }

            return result;
        }

        protected static double Sigmoid(double x)
        {
            return 1.0 / (1.0 + Math.Exp(-x));
        }
    }

    public class VisibleNeuron : Neuron
    {
        public override void Update()
        {
            this.Value = Sigmoid(nextGaussian(Random) + GetInputFromSourceNeurons() + Bias);
        }

        private static double nextGaussian(Random random)
        {
            return Math.Sqrt(-2.0 * Math.Log(random.NextDouble())) 
                * Math.Sin(2.0 * Math.PI * random.NextDouble()); 
        }

        public override void Learn(double learningRate)
        {
            this.DeltaBias += learningRate * this.Value;
        }
    }

    public class HiddenNeuron : Neuron
    {
        public double Probability;

        public override void Update()
        {
            this.Probability = Sigmoid(GetInputFromSourceNeurons() + Bias);
            this.Value = nextBool(Random, this.Probability) ? 1 : 0;
        }

        private static bool nextBool(Random random, double rate)
        {
            if (rate < 0 || 1 < rate) return false;
            return random.NextDouble() < rate;
        }

        public override void Learn(double learningRate)
        {
            this.DeltaBias += learningRate * this.Probability;
        }
    }
}

前回のソースコードと合わせると結果はこうなります:

0.99    0.46    0.94    0.04    0.00
0.01    0.10    0.89    0.66    0.93

まあいいんじゃないでしょうか?

拍手[0回]


GPUでニューラルネットワーク更新 (OpenCL)

ニューロン更新

Deep Learningに備えて色々やってみます。
Deep Learningは重いことがわかったので、GPUで計算をしましょう。

using Cloo;
using System.Linq;

class Program
{
    static void Main()
    {
        ComputePlatform platform = ComputePlatform.Platforms[0];
        ComputeDevice[] devices = platform
            .Devices
            .Where(d => d.Type == ComputeDeviceTypes.Gpu)
            .ToArray();
        ComputeContext context = new ComputeContext(
            devices,
            new ComputeContextPropertyList(platform),
            null,
            System.IntPtr.Zero
            );
        ComputeCommandQueue commandQueue = new ComputeCommandQueue(
            context,
            devices[0],
            ComputeCommandQueueFlags.None
            );
        ComputeProgram program = new ComputeProgram(
            context,
            System.IO.File.ReadAllText("myKernelProgram.cl")
            );
        try
        {
            program.Build(devices, null, null, System.IntPtr.Zero);
        }
        catch
        {
            System.Console.WriteLine(program.GetBuildLog(devices[0]));
        }

        ComputeKernel kernel = program.CreateKernel("updateVisibleNeurons");

        int visibleNeuronCount = 3;
        int hiddenNeuronCount = 2;
        ComputeBuffer<float> visibleNeuronValues = new ComputeBuffer<float>(
            context,
            ComputeMemoryFlags.ReadWrite,
            visibleNeuronCount
            );
        ComputeBuffer<float> visibleNeuronBiases = new ComputeBuffer<float>(
            context,
            ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer,
            new float[visibleNeuronCount]
            );
        ComputeBuffer<float> weights = new ComputeBuffer<float>(
            context,
            ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer,
            Enumerable.Range(0, visibleNeuronCount * hiddenNeuronCount).Select(i => (float)i).ToArray()
            );
        ComputeBuffer<float> hiddenNeuronValues = new ComputeBuffer<float>(
            context,
            ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer,
            Enumerable.Range(0, hiddenNeuronCount).Select(i => (float)i).ToArray()
            );
        kernel.SetMemoryArgument(0, visibleNeuronValues);
        kernel.SetMemoryArgument(1, visibleNeuronBiases);
        kernel.SetMemoryArgument(2, weights);
        kernel.SetMemoryArgument(3, hiddenNeuronValues);
        kernel.SetValueArgument(4, visibleNeuronCount);
        kernel.SetValueArgument(5, hiddenNeuronCount);


        commandQueue.Execute(
            kernel,
            null,
            new long[] { visibleNeuronCount },
            new long[] { 1 },
            null
            );
        float[] resultVisibleNeuronValues = new float[visibleNeuronCount];
        commandQueue.ReadFromBuffer(visibleNeuronValues, ref resultVisibleNeuronValues, true, null);

        foreach (var number in resultVisibleNeuronValues)
        {
            System.Console.WriteLine(number);
        }

        hiddenNeuronValues.Dispose();
        weights.Dispose();
        visibleNeuronBiases.Dispose();
        visibleNeuronValues.Dispose();

        kernel.Dispose();
        commandQueue.Dispose();
        program.Dispose();
        context.Dispose();
    }
}

GPUがわで動くプログラムはこちら:

myKernelProgram.cl

float sigmoid(float x)
{
	return 1.0f / (1.0f + exp(-x));
}

__kernel void updateVisibleNeurons(
	__global float *resultVisibleNeuronValues,
	__global float *visibleNeuronBiases, 
	__global float *weights, 
	__global float *hiddenNeuronValues,
	int visibleNeuronCount,
	int hiddenNeuronCount)
{
	int visibleNeuronIndex = get_global_id(0);
	float sum = 0;

	for(int i = 0; i < hiddenNeuronCount;i++)
	{
		sum += weights[visibleNeuronIndex * hiddenNeuronCount + i] * hiddenNeuronValues[i];
	}

	resultVisibleNeuronValues[visibleNeuronIndex] 
		= sigmoid(sum + visibleNeuronBiases[visibleNeuronIndex]);
}

このプログラムを実行すると、次のようになります:

0.7310586
0.9525741
0.9933071

上手く動いているようですね。
※sigmoid(1)は0.73...です。

拍手[1回]


かんたん!制限付きボルツマンマシン実装 実数(0から1)バージョン (C#) [Deep Learningシリーズ]

ニューロンの発火状態が実数

さて今回はあまり自信がありません。
もっとも私はいつも自信がないのですが、今回はいつもよりさらに自信がありません。
プログラムは上手く動くように見えるのですが、その理論的背景がよくわかりません!
間違いがあったら訂正していただけるとありがたいです。


[追記] どうもこちらのほうが正しいような気がしてきました。リンク先もご覧ください。どちらの性能が高いかというとこのページのやり方のほうがいい気がします。うーんどっちを使うべきなんでしょう?

[追記2] こちらもご覧ください。この記事のプログラムは、学習データに1が多いと上手く学習できないようです。それを修正しました。

今回のテーマは制限(制約)付きボルツマンマシンの実装、実数バージョンです。
この前の実装は、バイナリでした。
つまり、可視ニューロンには発火しているかどうかの2通りしかありませんでした。
発火状態は0か1かしか扱えなかったのです。
(その割には可視ニューロンの発火状態の型が(boolではなく)doubleだったりと妙なことになっていましたが)



バイナリなペンギン
2通りしか無いと画像はこうなります。)



拍手[0回]


かんたん!制限付きボルツマンマシン コントラスティブ・ダイバージェンス(Contrastive Divergence)法[Deep Learningシリーズ]

コントラスティブ・ダイバージェンス法

制限付きボルツマンマシン(Restricted Boltzmann Machine : RBM)は覚えたパターンを後で思い出す能力を持ったニューラルネットワークです。
あるパターンを覚え、後でそれに似たパターンを入力してやると、最初に教えたパターンを思い出すことができます。
制限付きボルツマンマシンはDeep Learningするネットワークの一部に使われています。
ですからDeep Learningしようと思ったら、制限付きボルツマンマシンを学んで損はないでしょう。



制限付きボルツマンマシンの学習には、コントラスティブ・ダイバージェンス(Contrastive Divergence : CD)という方法が有名なようです。
ですので、今回はこのコントラスティブ・ダイバージェンス法について解説します。

拍手[9回]