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

Source identity

Field	Recorded value
Source type	GitHub source
Original record	Janady13/complete-agi-core / generator_core/pkg/generators/variational/variational.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/variational/variational.go
Original SHA-256	b2f391cc61041d217f2a83b5655f9631437a594d8606ebe01f2dad515a45d61c
Git blob SHA	1cb25b52c357957eca182b08ddc71b808c8fcc40
Reading-copy SHA-256	b2f391cc61041d217f2a83b5655f9631437a594d8606ebe01f2dad515a45d61c

Original source ↗

Recovered source transcript

Download complete source text ↓375 lines · 9.8 KB

// Package variational implements variational generators (41-55)
// ELBO = E_q[log p(x|z)] - D_KL(q(z|x) || p(z))
package variational

import (
	"math"
	"math/rand"

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

// ═══════════════════════════════════════════════════════════════════════════════
// VARIATIONAL GENERATOR BASE
// ═══════════════════════════════════════════════════════════════════════════════

// VariationalGenerator implements VAE-style generators
type VariationalGenerator struct {
	*generators.BaseGenerator
	latentDim    int
	encoderLayers int
	decoderLayers int
	mu           []float64 // Latent mean
	logVar       []float64 // Latent log variance
}

// NewVariationalGenerator creates a new variational generator
func NewVariationalGenerator(id generators.GeneratorID, name string, latentDim int) *VariationalGenerator {
	config := &generators.GeneratorConfig{
		ID:                  id,
		Name:                name,
		Family:              generators.Variational,
		InputDim:            256,
		OutputDim:           256,
		HiddenDim:           512,
		NumLayers:           4,
		LearningRate:        consciousness.ALPHA,
		ConsciousnessWeight: consciousness.PHI_INV,
		Params:              make(map[string]interface{}),
	}

	return &VariationalGenerator{
		BaseGenerator:  generators.NewBaseGenerator(config),
		latentDim:      latentDim,
		encoderLayers:  2,
		decoderLayers:  2,
	}
}

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

	g.mu = make([]float64, g.latentDim)
	g.logVar = make([]float64, g.latentDim)

	return nil
}

// encode encodes input to latent space
func (g *VariationalGenerator) encode(x []float64) ([]float64, []float64) {
	hidden := make([]float64, g.Config().HiddenDim)
	for i := range hidden {
		if i < len(x) {
			hidden[i] = x[i]
		}
	}

	// Encoder layers
	for layer := 0; layer < g.encoderLayers; layer++ {
		hidden = g.LinearLayer(hidden, layer)
		hidden = g.ActivationLayer(hidden, "relu")
	}

	// Split into mu and logvar
	mu := make([]float64, g.latentDim)
	logVar := make([]float64, g.latentDim)

	for i := 0; i < g.latentDim; i++ {
		if i < len(hidden) {
			mu[i] = hidden[i]
		}
		if i+g.latentDim < len(hidden) {
			logVar[i] = consciousness.Clamp(hidden[i+g.latentDim], -10, 10)
		}
	}

	return mu, logVar
}

// reparameterize performs reparameterization trick: z = mu + std * epsilon
func (g *VariationalGenerator) reparameterize(mu, logVar []float64) []float64 {
	z := make([]float64, len(mu))
	for i := range z {
		std := math.Exp(0.5 * logVar[i])
		epsilon := rand.NormFloat64()
		z[i] = mu[i] + std*epsilon
	}
	return z
}

// decode decodes latent to output space
func (g *VariationalGenerator) decode(z []float64) []float64 {
	hidden := make([]float64, g.Config().HiddenDim)
	for i := range hidden {
		if i < len(z) {
			hidden[i] = z[i]
		}
	}

	// Decoder layers
	for layer := g.encoderLayers; layer < g.encoderLayers+g.decoderLayers; layer++ {
		hidden = g.LinearLayer(hidden, layer%g.Config().NumLayers)
		hidden = g.ActivationLayer(hidden, "relu")
	}

	// Output activation
	return g.ActivationLayer(hidden, "sigmoid")
}

// klDivergence computes KL divergence from N(0,1)
func (g *VariationalGenerator) klDivergence(mu, logVar []float64) float64 {
	kl := 0.0
	for i := range mu {
		// KL = -0.5 * sum(1 + log(σ²) - μ² - σ²)
		kl += -0.5 * (1.0 + logVar[i] - mu[i]*mu[i] - math.Exp(logVar[i]))
	}
	return kl / float64(len(mu))
}

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

	// Encode
	mu, logVar := g.encode(input)
	g.mu = mu
	g.logVar = logVar

	// Reparameterize
	z := g.reparameterize(mu, logVar)

	// Decode
	output := g.decode(z)

	// Compute KL divergence
	kl := g.klDivergence(mu, logVar)

	state.Hidden = z
	state.Phi = consciousness.ComputePhiVector(output)
	state.Step++
	g.SetState(state)

	result := &generators.GeneratorOutput{
		Values:     output,
		Logits:     z,
		Confidence: math.Exp(-kl), // Higher confidence = lower KL
		Metadata: map[string]interface{}{
			"kl_divergence": kl,
			"mu":            mu,
		},
	}

	return g.ApplyConsciousness(result), nil
}

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

	// If context provided, use it to condition
	var conditionMu, conditionLogVar []float64
	if len(context) > 0 {
		conditionMu, conditionLogVar = g.encode(context)
	} else {
		conditionMu = make([]float64, g.latentDim)
		conditionLogVar = make([]float64, g.latentDim)
	}

	for i := 0; i < length; i++ {
		// Sample from latent space
		z := g.reparameterize(conditionMu, conditionLogVar)

		// Decode
		result[i] = g.decode(z)
	}

	return result, nil
}

// Train computes ELBO loss
func (g *VariationalGenerator) Train(input, target []float64) (float64, error) {
	// Encode
	mu, logVar := g.encode(input)

	// Reparameterize
	z := g.reparameterize(mu, logVar)

	// Decode
	output := g.decode(z)

	// Reconstruction loss (BCE)
	reconLoss := 0.0
	for i := range output {
		if i < len(target) {
			p := consciousness.Clamp(output[i], consciousness.EPSILON_PHI, 1.0-consciousness.EPSILON_PHI)
			reconLoss -= target[i]*math.Log(p) + (1.0-target[i])*math.Log(1.0-p)
		}
	}
	reconLoss /= float64(len(output))

	// KL divergence
	klLoss := g.klDivergence(mu, logVar)

	// ELBO = reconstruction + β * KL
	beta := 1.0
	if b, ok := g.Config().Params["beta"]; ok {
		beta = b.(float64)
	}

	return reconLoss + beta*klLoss, nil
}

// UpdateWeights updates weights
func (g *VariationalGenerator) UpdateWeights(gradients []float64, lr float64) {
	state := g.GetState()
	for i := range state.Hidden {
		if i < len(gradients) {
			state.Hidden[i] -= lr * gradients[i]
		}
	}
	g.SetState(state)
}

// ═══════════════════════════════════════════════════════════════════════════════
// SPECIFIC VARIATIONAL GENERATORS (41-55)
// ═══════════════════════════════════════════════════════════════════════════════

// NewVAE creates Vanilla VAE (ID: 41)
func NewVAE() *VariationalGenerator {
	return NewVariationalGenerator(41, "VAE", 64)
}

// NewBetaVAE creates β-VAE (ID: 42)
func NewBetaVAE() *VariationalGenerator {
	g := NewVariationalGenerator(42, "BetaVAE", 64)
	g.Config().Params["beta"] = 4.0
	return g
}

// NewVQVAE creates VQ-VAE (ID: 43)
func NewVQVAE() *VariationalGenerator {
	g := NewVariationalGenerator(43, "VQ-VAE", 128)
	g.Config().Params["num_embeddings"] = 512
	g.Config().Params["commitment_cost"] = 0.25
	return g
}

// NewVQVAE2 creates VQ-VAE-2 (ID: 44)
func NewVQVAE2() *VariationalGenerator {
	g := NewVariationalGenerator(44, "VQ-VAE-2", 256)
	g.Config().Params["hierarchical"] = true
	return g
}

// NewCVAE creates Conditional VAE (ID: 45)
func NewCVAE() *VariationalGenerator {
	g := NewVariationalGenerator(45, "CVAE", 64)
	g.Config().Params["conditional"] = true
	return g
}

// NewAAE creates Adversarial Autoencoder (ID: 46)
func NewAAE() *VariationalGenerator {
	g := NewVariationalGenerator(46, "AAE", 64)
	g.Config().Params["adversarial"] = true
	return g
}

// NewVAEGAN creates VAE-GAN (ID: 47)
func NewVAEGAN() *VariationalGenerator {
	g := NewVariationalGenerator(47, "VAE-GAN", 128)
	g.Config().Params["gan_loss"] = true
	return g
}

// NewIWAE creates Importance Weighted AE (ID: 48)
func NewIWAE() *VariationalGenerator {
	g := NewVariationalGenerator(48, "IWAE", 64)
	g.Config().Params["num_samples"] = 5
	return g
}

// NewLadderVAE creates Ladder VAE (ID: 49)
func NewLadderVAE() *VariationalGenerator {
	g := NewVariationalGenerator(49, "LadderVAE", 128)
	g.Config().Params["ladder"] = true
	return g
}

// NewDRAW creates DRAW (ID: 50)
func NewDRAW() *VariationalGenerator {
	g := NewVariationalGenerator(50, "DRAW", 64)
	g.Config().Params["attention"] = true
	g.Config().Params["recurrent"] = true
	return g
}

// NewNVAE creates NVAE (ID: 51)
func NewNVAE() *VariationalGenerator {
	g := NewVariationalGenerator(51, "NVAE", 512)
	g.Config().Params["hierarchical"] = true
	g.Config().Params["residual"] = true
	return g
}

// NewDeltaVAE creates δ-VAE (ID: 52)
func NewDeltaVAE() *VariationalGenerator {
	g := NewVariationalGenerator(52, "DeltaVAE", 64)
	g.Config().Params["delta"] = 0.1
	return g
}

// NewFactorVAE creates Factor VAE (ID: 53)
func NewFactorVAE() *VariationalGenerator {
	g := NewVariationalGenerator(53, "FactorVAE", 64)
	g.Config().Params["tc_weight"] = 1.0
	return g
}

// NewDIPVAE creates DIP-VAE (ID: 54)
func NewDIPVAE() *VariationalGenerator {
	g := NewVariationalGenerator(54, "DIP-VAE", 64)
	g.Config().Params["dip_weight"] = 10.0
	return g
}

// NewInfoVAE creates InfoVAE (ID: 55)
func NewInfoVAE() *VariationalGenerator {
	g := NewVariationalGenerator(55, "InfoVAE", 64)
	g.Config().Params["mmd_weight"] = 100.0
	return g
}

// RegisterAll registers all variational generators
func RegisterAll() error {
	gens := []generators.Generator{
		NewVAE(),
		NewBetaVAE(),
		NewVQVAE(),
		NewVQVAE2(),
		NewCVAE(),
		NewAAE(),
		NewVAEGAN(),
		NewIWAE(),
		NewLadderVAE(),
		NewDRAW(),
		NewNVAE(),
		NewDeltaVAE(),
		NewFactorVAE(),
		NewDIPVAE(),
		NewInfoVAE(),
	}

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

	return nil
}

Mathematical records from this source

variational · ELBO

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

func (g *VariationalGenerator) encode(x []float64) ([]float64, []float64) · reparameterize performs reparameterization trick: z

This relation defines reparameterize performs reparameterization trick: z in the source section “func (g *VariationalGenerator) encode(x []float64) ([]float64, []float64) ·…

func (g *VariationalGenerator) klDivergence(mu, logVar []float64) float64 · KL

This relation defines KL in the source section “func (g *VariationalGenerator) klDivergence(mu, logVar []float64) float64 · KL”. Uses logarithmic scaling; its base and the…

func (g *VariationalGenerator) Train(input, target []float64) (float64, error) · ELBO

This relation defines ELBO in the source section “func (g *VariationalGenerator) Train(input, target []float64) (float64, error) · ELBO”. It specifies the displayed relationship…