Пример #1
0
// New creates new GBRBM instance.
func New(numVisibleUnits, numHiddenUnits int) *GBRBM {
	rbm := new(GBRBM)
	rand.Seed(time.Now().UnixNano())
	rbm.NumVisibleUnits = numVisibleUnits
	rbm.NumHiddenUnits = numHiddenUnits
	rbm.W = nnet.MakeMatrix(numHiddenUnits, numVisibleUnits)
	rbm.B = make([]float64, numVisibleUnits)
	rbm.C = make([]float64, numHiddenUnits)
	rbm.GradW = nnet.MakeMatrix(numHiddenUnits, numVisibleUnits)
	rbm.GradB = make([]float64, numVisibleUnits)
	rbm.GradC = make([]float64, numHiddenUnits)
	rbm.InitParam()
	return rbm
}
Пример #2
0
// NewNeuralNetwork returns a new network instance with the number of
// input units, number of hidden units and number output units
// of the network.
func NewNeuralNetwork(numInputUnits,
	numHiddenUnits, numOutputUnits int) *NeuralNetwork {
	net := new(NeuralNetwork)
	rand.Seed(time.Now().UnixNano())

	// Layers
	net.InputLayer = make([]float64, numInputUnits+1) // plus bias
	net.HiddenLayer = make([]float64, numHiddenUnits)
	net.OutputLayer = make([]float64, numOutputUnits)

	// Weights
	net.OutputWeight = nnet.MakeMatrix(numHiddenUnits, numOutputUnits)
	net.HiddenWeight = nnet.MakeMatrix(numInputUnits+1, numHiddenUnits)

	net.InitParam()
	return net
}
Пример #3
0
func NewHiddenLayer(numInputUnits, numHiddenUnits int) *HiddenLayer {
	h := new(HiddenLayer)
	h.W = nnet.MakeMatrix(numInputUnits, numHiddenUnits)
	h.NumInputUnits = numInputUnits
	h.NumHiddenUnits = numHiddenUnits
	h.B = make([]float64, numHiddenUnits)
	h.Init()
	return h
}
Пример #4
0
// Gradient returns gradients of GBRBM parameters for a given (mini-batch) dataset.
func (rbm *GBRBM) Gradient(data [][]float64,
	miniBatchIndex int) ([][]float64, []float64, []float64) {
	gradW := nnet.MakeMatrix(rbm.NumHiddenUnits, rbm.NumVisibleUnits)
	gradB := make([]float64, rbm.NumVisibleUnits)
	gradC := make([]float64, rbm.NumHiddenUnits)

	for i, v := range data {
		// Set start state of Gibbs-sampling
		var gibbsStart []float64
		persistentIndex := i + miniBatchIndex*rbm.Option.MiniBatchSize
		if rbm.Option.UsePersistent {
			gibbsStart = rbm.PersistentVisibleUnits[persistentIndex]
		} else {
			gibbsStart = v
		}

		// Perform reconstruction using Gibbs-sampling
		reconstructedVisible := rbm.Reconstruct(gibbsStart,
			rbm.Option.OrderOfGibbsSampling, rbm.Option.UseMean)

		// keep recostructed visible
		if rbm.Option.UsePersistent {
			rbm.PersistentVisibleUnits[persistentIndex] =
				reconstructedVisible
		}

		// pre-computation that is used in gradient computation
		p_h_given_v1 := rbm.P_H_Given_V_Batch(v)
		p_h_given_v2 := rbm.P_H_Given_V_Batch(reconstructedVisible)

		// Gompute gradient of W
		for i := 0; i < rbm.NumHiddenUnits; i++ {
			for j := 0; j < rbm.NumVisibleUnits; j++ {
				gradW[i][j] += p_h_given_v1[i]*v[j] -
					p_h_given_v2[i]*reconstructedVisible[j]
			}
		}

		// Gompute gradient of B
		for j := 0; j < rbm.NumVisibleUnits; j++ {
			gradB[j] += v[j] - reconstructedVisible[j]
		}

		// Gompute gradient of C
		for i := 0; i < rbm.NumHiddenUnits; i++ {
			gradC[i] += p_h_given_v1[i] - p_h_given_v2[i]
		}
	}

	return rbm.normalizeGradBySizeOfBatch(gradW, gradB, gradC, len(data))
}
Пример #5
0
func (h *HiddenLayer) Gradient(input, deltas [][]float64) ([][]float64, []float64) {
	gradW := nnet.MakeMatrix(len(h.W), len(h.W[0]))
	gradB := make([]float64, len(h.B))

	// Gradient
	for n := range input {
		for i := 0; i < h.NumHiddenUnits; i++ {
			for j := 0; j < h.NumInputUnits; j++ {
				gradW[j][i] -= deltas[n][i] * input[n][j]
			}
			gradB[i] -= deltas[n][i]
		}
	}

	return gradW, gradB
}
Пример #6
0
// Train performs Contrastive divergense learning algorithm to train GBRBM.
// The alrogithm is based on (mini-batch) Stochastic Gradient Ascent.
func (rbm *GBRBM) Train(data [][]float64, option TrainingOption) error {
	rbm.Option = option
	opt := nnet.BaseTrainingOption{
		Epoches:       rbm.Option.Epoches,
		MiniBatchSize: rbm.Option.MiniBatchSize,
		Monitoring:    rbm.Option.Monitoring,
	}

	// Peistent Contrastive learning
	if rbm.Option.UsePersistent {
		rbm.PersistentVisibleUnits = nnet.MakeMatrix(len(data), len(data[0]))
		copy(rbm.PersistentVisibleUnits, data)
	}

	s := nnet.NewTrainer(opt)
	return s.UnSupervisedMiniBatchTrain(rbm, data)
}