Janady13/complete-agi-core / generator_core/pkg/generators/recurrent/recurrent.go

Source identity

Field	Recorded value
Source type	GitHub source
Original record	Janady13/complete-agi-core / generator_core/pkg/generators/recurrent/recurrent.go
Date	Not specified in source
Repository	Janady13/complete-agi-core
Revision	33aa84f2aa61cedbe010240ada7f4efbdfe795a7
Branch	claude/improve-math-logic-ehIW1
Path or archive member	generator_core/pkg/generators/recurrent/recurrent.go
Original SHA-256	6b31ae881fa37bbf5cb28b3dee2e5f21ab641e1ee61c179f9039610bccd68f24
Git blob SHA	bd7847f1720b50176419bdbbcf8eb2e846825e49
Reading-copy SHA-256	6b31ae881fa37bbf5cb28b3dee2e5f21ab641e1ee61c179f9039610bccd68f24

Original source ↗

Recovered source transcript

Download complete source text ↓425 lines · 10.0 KB

// Package recurrent implements recurrent generators (86-92)
// h_t = f(h_{t-1}, x_t)
package recurrent

import (
	"math"

	"generator_core/pkg/consciousness"
	"generator_core/pkg/generators"
)

// ═══════════════════════════════════════════════════════════════════════════════
// RECURRENT GENERATOR BASE
// ═══════════════════════════════════════════════════════════════════════════════

// RecurrentGenerator implements RNN-based generators
type RecurrentGenerator struct {
	*generators.BaseGenerator
	rnnType      string
	hiddenSize   int
	numLayers    int
	Wih          [][]float64 // Input to hidden
	Whh          [][]float64 // Hidden to hidden
	bh           []float64   // Hidden bias
}

// NewRecurrentGenerator creates a new recurrent generator
func NewRecurrentGenerator(id generators.GeneratorID, name string, rnnType string, hiddenSize int) *RecurrentGenerator {
	config := &generators.GeneratorConfig{
		ID:                  id,
		Name:                name,
		Family:              generators.Recurrent,
		InputDim:            256,
		OutputDim:           256,
		HiddenDim:           hiddenSize,
		NumLayers:           2,
		LearningRate:        consciousness.ALPHA,
		ConsciousnessWeight: consciousness.PHI_INV,
		Params:              make(map[string]interface{}),
	}

	return &RecurrentGenerator{
		BaseGenerator: generators.NewBaseGenerator(config),
		rnnType:       rnnType,
		hiddenSize:    hiddenSize,
		numLayers:     2,
	}
}

// Initialize initializes the recurrent generator
func (g *RecurrentGenerator) Initialize() error {
	if err := g.BaseGenerator.Initialize(); err != nil {
		return err
	}

	inputDim := g.Config().InputDim

	// Initialize weight matrices
	g.Wih = make([][]float64, g.hiddenSize)
	g.Whh = make([][]float64, g.hiddenSize)
	g.bh = make([]float64, g.hiddenSize)

	for i := 0; i < g.hiddenSize; i++ {
		g.Wih[i] = make([]float64, inputDim)
		g.Whh[i] = make([]float64, g.hiddenSize)

		for j := 0; j < inputDim; j++ {
			g.Wih[i][j] = (float64((i+j)%100)/100.0 - 0.5) * consciousness.PHI_INV / math.Sqrt(float64(inputDim))
		}
		for j := 0; j < g.hiddenSize; j++ {
			g.Whh[i][j] = (float64((i+j)%100)/100.0 - 0.5) * consciousness.PHI_INV / math.Sqrt(float64(g.hiddenSize))
		}
	}

	return nil
}

// rnnStep performs one RNN step: h = tanh(W_ih * x + W_hh * h + b)
func (g *RecurrentGenerator) rnnStep(x, h []float64) []float64 {
	hNew := make([]float64, g.hiddenSize)

	for i := 0; i < g.hiddenSize; i++ {
		sum := g.bh[i]

		// Input contribution
		for j := range x {
			if j < len(g.Wih[i]) {
				sum += g.Wih[i][j] * x[j]
			}
		}

		// Hidden contribution
		for j := range h {
			if j < len(g.Whh[i]) {
				sum += g.Whh[i][j] * h[j]
			}
		}

		hNew[i] = consciousness.Tanh(sum)
	}

	return hNew
}

// lstmStep performs one LSTM step
func (g *RecurrentGenerator) lstmStep(x, h, c []float64) ([]float64, []float64) {
	// Gates: forget, input, output, candidate
	f := make([]float64, g.hiddenSize)
	i := make([]float64, g.hiddenSize)
	o := make([]float64, g.hiddenSize)
	cCandidate := make([]float64, g.hiddenSize)

	for k := 0; k < g.hiddenSize; k++ {
		// Forget gate
		sumF := 0.0
		for j := range x {
			if j < len(g.Wih[k]) {
				sumF += g.Wih[k][j] * x[j] * 0.25
			}
		}
		for j := range h {
			if j < len(g.Whh[k]) {
				sumF += g.Whh[k][j] * h[j] * 0.25
			}
		}
		f[k] = consciousness.Sigmoid(sumF + 1.0) // Bias towards remembering

		// Input gate
		sumI := 0.0
		for j := range x {
			if j < len(g.Wih[k]) {
				sumI += g.Wih[k][j] * x[j] * 0.25
			}
		}
		for j := range h {
			if j < len(g.Whh[k]) {
				sumI += g.Whh[k][j] * h[j] * 0.25
			}
		}
		i[k] = consciousness.Sigmoid(sumI)

		// Output gate
		sumO := 0.0
		for j := range x {
			if j < len(g.Wih[k]) {
				sumO += g.Wih[k][j] * x[j] * 0.25
			}
		}
		for j := range h {
			if j < len(g.Whh[k]) {
				sumO += g.Whh[k][j] * h[j] * 0.25
			}
		}
		o[k] = consciousness.Sigmoid(sumO)

		// Candidate
		sumC := 0.0
		for j := range x {
			if j < len(g.Wih[k]) {
				sumC += g.Wih[k][j] * x[j] * 0.25
			}
		}
		for j := range h {
			if j < len(g.Whh[k]) {
				sumC += g.Whh[k][j] * h[j] * 0.25
			}
		}
		cCandidate[k] = consciousness.Tanh(sumC)
	}

	// Update cell state and hidden
	cNew := make([]float64, g.hiddenSize)
	hNew := make([]float64, g.hiddenSize)

	for k := 0; k < g.hiddenSize; k++ {
		ck := 0.0
		if k < len(c) {
			ck = c[k]
		}
		cNew[k] = f[k]*ck + i[k]*cCandidate[k]
		hNew[k] = o[k] * consciousness.Tanh(cNew[k])
	}

	return hNew, cNew
}

// gruStep performs one GRU step
func (g *RecurrentGenerator) gruStep(x, h []float64) []float64 {
	// Reset and update gates
	r := make([]float64, g.hiddenSize)
	z := make([]float64, g.hiddenSize)
	hCandidate := make([]float64, g.hiddenSize)

	for k := 0; k < g.hiddenSize; k++ {
		// Reset gate
		sumR := 0.0
		for j := range x {
			if j < len(g.Wih[k]) {
				sumR += g.Wih[k][j] * x[j] * 0.5
			}
		}
		for j := range h {
			if j < len(g.Whh[k]) {
				sumR += g.Whh[k][j] * h[j] * 0.5
			}
		}
		r[k] = consciousness.Sigmoid(sumR)

		// Update gate
		sumZ := 0.0
		for j := range x {
			if j < len(g.Wih[k]) {
				sumZ += g.Wih[k][j] * x[j] * 0.5
			}
		}
		for j := range h {
			if j < len(g.Whh[k]) {
				sumZ += g.Whh[k][j] * h[j] * 0.5
			}
		}
		z[k] = consciousness.Sigmoid(sumZ)

		// Candidate
		sumH := 0.0
		for j := range x {
			if j < len(g.Wih[k]) {
				sumH += g.Wih[k][j] * x[j]
			}
		}
		for j := range h {
			if j < len(g.Whh[k]) {
				sumH += g.Whh[k][j] * (r[k] * h[j])
			}
		}
		hCandidate[k] = consciousness.Tanh(sumH)
	}

	// Update hidden
	hNew := make([]float64, g.hiddenSize)
	for k := 0; k < g.hiddenSize; k++ {
		hk := 0.0
		if k < len(h) {
			hk = h[k]
		}
		hNew[k] = (1.0-z[k])*hk + z[k]*hCandidate[k]
	}

	return hNew
}

// Forward performs forward pass
func (g *RecurrentGenerator) Forward(input []float64) (*generators.GeneratorOutput, error) {
	state := g.GetState()

	h := state.Hidden
	if len(h) != g.hiddenSize {
		h = make([]float64, g.hiddenSize)
	}

	c := state.Memory
	if len(c) != g.hiddenSize {
		c = make([]float64, g.hiddenSize)
	}

	// Process input sequence
	seqLen := len(input) / g.Config().InputDim
	if seqLen == 0 {
		seqLen = 1
	}

	for t := 0; t < seqLen; t++ {
		start := t * g.Config().InputDim
		end := start + g.Config().InputDim
		if end > len(input) {
			end = len(input)
		}

		x := input[start:end]

		switch g.rnnType {
		case "lstm":
			h, c = g.lstmStep(x, h, c)
		case "gru":
			h = g.gruStep(x, h)
		default:
			h = g.rnnStep(x, h)
		}
	}

	state.Hidden = h
	state.Memory = c
	state.Phi = consciousness.ComputePhiVector(h)
	state.Step++
	g.SetState(state)

	output := &generators.GeneratorOutput{
		Values:     h,
		Logits:     h,
		Confidence: state.Phi,
		Metadata: map[string]interface{}{
			"rnn_type": g.rnnType,
			"seq_len":  seqLen,
		},
	}

	return g.ApplyConsciousness(output), nil
}

// Generate generates sequence
func (g *RecurrentGenerator) Generate(context []float64, length int) ([][]float64, error) {
	result := make([][]float64, length)

	// Initialize from context
	_, _ = g.Forward(context)

	for i := 0; i < length; i++ {
		state := g.GetState()
		output, err := g.Forward(state.Hidden)
		if err != nil {
			return nil, err
		}
		result[i] = output.Values
	}

	return result, nil
}

// Train computes loss
func (g *RecurrentGenerator) Train(input, target []float64) (float64, error) {
	output, err := g.Forward(input)
	if err != nil {
		return 0, err
	}

	// MSE loss
	loss := 0.0
	for i := range output.Values {
		if i < len(target) {
			diff := output.Values[i] - target[i]
			loss += diff * diff
		}
	}

	return loss / float64(len(output.Values)), nil
}

// UpdateWeights updates weights
func (g *RecurrentGenerator) UpdateWeights(gradients []float64, lr float64) {
	for i := range g.Wih {
		for j := range g.Wih[i] {
			if j < len(gradients) {
				g.Wih[i][j] -= lr * gradients[j] * consciousness.PHI_INV
			}
		}
	}
}

// ═══════════════════════════════════════════════════════════════════════════════
// SPECIFIC RECURRENT GENERATORS (86-92)
// ═══════════════════════════════════════════════════════════════════════════════

// NewVanillaRNN creates Vanilla RNN (ID: 86)
func NewVanillaRNN() *RecurrentGenerator {
	return NewRecurrentGenerator(86, "VanillaRNN", "rnn", 256)
}

// NewLSTM creates LSTM (ID: 87)
func NewLSTM() *RecurrentGenerator {
	return NewRecurrentGenerator(87, "LSTM", "lstm", 256)
}

// NewGRU creates GRU (ID: 88)
func NewGRU() *RecurrentGenerator {
	return NewRecurrentGenerator(88, "GRU", "gru", 256)
}

// NewBiLSTM creates Bidirectional LSTM (ID: 89)
func NewBiLSTM() *RecurrentGenerator {
	g := NewRecurrentGenerator(89, "BiLSTM", "lstm", 256)
	g.Config().Params["bidirectional"] = true
	return g
}

// NewStackedLSTM creates Stacked LSTM (ID: 90)
func NewStackedLSTM() *RecurrentGenerator {
	g := NewRecurrentGenerator(90, "StackedLSTM", "lstm", 256)
	g.numLayers = 4
	return g
}

// NewIndRNN creates IndRNN (ID: 91)
func NewIndRNN() *RecurrentGenerator {
	g := NewRecurrentGenerator(91, "IndRNN", "rnn", 256)
	g.Config().Params["independent"] = true
	return g
}

// NewMGU creates Minimal Gated Unit (ID: 92)
func NewMGU() *RecurrentGenerator {
	g := NewRecurrentGenerator(92, "MGU", "gru", 256)
	g.Config().Params["minimal"] = true
	return g
}

// RegisterAll registers all recurrent generators
func RegisterAll() error {
	gens := []generators.Generator{
		NewVanillaRNN(),
		NewLSTM(),
		NewGRU(),
		NewBiLSTM(),
		NewStackedLSTM(),
		NewIndRNN(),
		NewMGU(),
	}

	for _, g := range gens {
		if err := generators.Register(g); err != nil {
			return err
		}
	}

	return nil
}

Mathematical records from this source

recurrent · h_t

This relation defines h_t in the source section “recurrent · h_t”. It specifies the displayed relationship between the named quantities or parameters. Its interpretation depends…

func (g *RecurrentGenerator) Initialize() error · rnnStep performs one RNN step: h

This relation defines rnnStep performs one RNN step: h in the source section “func (g *RecurrentGenerator) Initialize() error · rnnStep performs one RNN step: h”. It specifies the…