Golang data.Bitset類代碼示例

func (s ScalarSensor) Decode(bits data.Bitset) interface{} {
	found := bits.Any(func(int) bool {
		return true
	})

	return (0.5+float64(found))*s.BucketSize + s.MinValue
}

func (c *Column) LearnSequence(learnState data.Bitset) {
	logEnabled := log.HtmLogger.Enabled()
	if learnState.IsZero() {
		// Select the learning cell, but don't increment the target.
		c.learning = c.learningTarget
		if logEnabled {
			log.HtmLogger.Printf("\t(%d, %d)=%04d: skip learning empty sequence",
				c.Index, c.learning, c.CellId(c.learning))
		}
		return
	}
	cell, sIndex, _ := c.FindBestSegment(learnState, 1, true)
	if sIndex >= 0 {
		if logEnabled {
			log.HtmLogger.Printf("\t(%d, %d)=%04d: Will reinforce segment: %v",
				c.Index, cell, c.CellId(cell), c.distal[cell].Segment(sIndex))
		}
	} else {
		if logEnabled {
			log.HtmLogger.Printf("\t(%d, %d)=%04d: Will learn a new segment.",
				c.Index, c.learningTarget, c.CellId(c.learningTarget))
		}
		cell = c.learningTarget
		c.learningTarget = (c.learningTarget + 1) % c.Height()
		sIndex = -1
	}
	c.learning = cell
	update := c.distal[cell].CreateUpdate(sIndex, learnState, 1)
	if logEnabled {
		log.HtmLogger.Printf("\tLearning sequence %v => (%d, %d)=%04d",
			update, c.Index, cell, c.CellId(cell))
	}
	c.distal[cell].Apply(update, true)
}

func (c Column) FindBestSegment(state data.Bitset, minOverlap int, weak bool) (bestCell, bestSegment, bestOverlap int) {
	bestCell = -1
	bestSegment = -1
	bestOverlap = minOverlap - 1
	maxOverlap := state.NumSetBits()
	for i := 0; i < c.Height(); i++ {
		sIndex, sOverlap := c.distal[i].ComputeActive(state, minOverlap, weak)
		if sOverlap > bestOverlap {
			bestCell = i
			bestSegment = sIndex
			bestOverlap = sOverlap
			if bestOverlap == maxOverlap {
				break
			}
		}
	}
	if log.HtmLogger.Enabled() {
		if bestSegment >= 0 {
			s := c.distal[bestCell].Segment(bestSegment)
			log.HtmLogger.Printf("\t\tFind best segment for column=%d, state=%v, minOverlap=%d, weak=%t: (%d, %d)=%04d <= %v (overlap=%d)",
				c.Index, state, minOverlap, weak, c.Index, bestCell, c.CellId(bestCell),
				s.Connected(), bestOverlap)
		}
	}
	return
}

func (pm *PermanenceMap) weaken(input data.Bitset) {
	for k, v := range pm.permanence {
		if input.IsSet(k) {
			v -= pm.config.Decrement
		}
		pm.Set(k, v)
	}
}

func PermanenceMapFromBits(bits data.Bitset) (pm *PermanenceMap) {
	pm = NewPermanenceMap(bits.Len())
	bits.Foreach(func(k int) {
		pm.permanence[k] = pm.config.Initial
	})
	if pm.config.Initial > pm.config.Threshold {
		pm.synapses.Or(bits)
	}
	return pm
}

func (pm *PermanenceMap) narrow(input data.Bitset) {
	for k, v := range pm.permanence {
		if input.IsSet(k) {
			v += pm.config.Increment
		} else {
			v -= pm.config.Decrement
		}
		pm.Set(k, v)
	}
}

func (c *Column) ConfirmPrediction(state data.Bitset) bool {
	if c.learning >= 0 && state.IsSet(c.CellId(c.learning)) {
		if log.HtmLogger.Enabled() {
			log.HtmLogger.Printf("\t(%d, %d)=%04d: Confirmed prediction.",
				c.Index, c.learning, c.CellId(c.learning))
		}
		return true
	}
	return false
}

func (l *Region) FeedBack(output data.Bitset) *data.Bitset {
	dest := data.NewBitset(l.InputLength)
	output.Foreach(func(cellId int) {
		col := l.columns[cellId/l.Height()]
		cell := cellId % l.Height()
		if !col.Distal(cell).HasActiveSegment(output, l.MinimumInputOverlap) {
			// Not a predicted cell, must be active from fast-forward.
			dest.Or(col.Connected())
		}
	})
	return dest
}

func (g *DistalSegmentGroup) CreateUpdate(sIndex int, activeState data.Bitset, minSynapses int) *SegmentUpdate {
	state := data.NewBitset(activeState.Len())
	if sIndex >= 0 {
		s := g.segments[sIndex]
		state.ResetTo(s.Connected())
	}
	state.Or(activeState)
	for num := state.NumSetBits(); num < minSynapses; num = state.NumSetBits() {
		// TODO(tms): optimize.
		indices := segmentRand.Perm(state.Len())[num:minSynapses]
		state.Set(indices...)
	}
	return NewSegmentUpdate(sIndex, state)
}

func (ds *DendriteSegment) broaden(input data.Bitset, minOverlap int) (overlapCount int) {
	overlapCount = input.Overlap(ds.Connected())
	threshold := ds.Config().Threshold
	newPermanence := ds.Config().Minimum + ds.Boost
	if newPermanence > threshold {
		newPermanence = threshold
	}
	newSynapses := input.Clone()
	newSynapses.AndNot(ds.ReceptiveField())
	newSynapses.Foreach(func(k int) {
		v := ds.Get(k)
		if v < newPermanence {
			ds.Set(k, newPermanence)
		}
	})
	ds.overlapHistory.Record(overlapCount >= minOverlap)
	if avg, ok := ds.overlapHistory.Average(); ok && avg < ds.MinActivityRatio {
		for k, v := range ds.permanence {
			ds.Set(k, v*1.01)
		}
	}
	return
}