from neurogebra import MathForge

forge = MathForge()

# Retrieve any of the 285 pre-built expressions by name
relu = forge.get("relu")
print(relu.eval(x=5))         # 5
print(relu.eval(x=-3))        # 0
print(relu.formula)            # LaTeX symbolic representation
print(relu.explain())          # Plain-language explanation

# Access optimizers, losses, metrics, distributions -- all the same way
adam   = forge.get("adam_step")
gauss  = forge.get("gaussian")
f1     = forge.get("f1_score_formula")

# Search and discover
results = forge.search("classification")
forge.list_all(category="activation")
forge.compare(["relu", "sigmoid", "tanh"])

forge = MathForge()
cross_entropy = forge.get("cross_entropy")
print(cross_entropy.formula)       # Symbolic LaTeX
print(cross_entropy.eval(y=1, y_pred=0.9))  # Numerical result
print(cross_entropy.explain())     # What it is and when to use it

from neurogebra import Expression
from neurogebra.core.trainer import Trainer

expr = Expression("fit_line", "m*x + b", params={"m": 0.0, "b": 0.0}, trainable_params=["m", "b"])
trainer = Trainer(expr, learning_rate=0.01, optimizer="adam")
history = trainer.fit(X, y, epochs=200, verbose=True)

mse = forge.get("mse")
mae = forge.get("mae")
custom_loss = 0.7 * mse + 0.3 * mae

from neurogebra.builders.model_builder import ModelBuilder

builder = ModelBuilder()
model = builder.Sequential([
    builder.Dense(64, activation="relu"),
    builder.Dense(32, activation="tanh"),
    builder.Dense(1, activation="sigmoid"),
], name="classifier")

model.compile(
    loss="binary_crossentropy",
    optimizer="adam",
    learning_rate=0.01,
    log_level="expert",          # <-- this is all you need
)

model.fit(X_train, y_train, epochs=20, batch_size=32)

from neurogebra.logging.config import LogConfig

config = LogConfig.minimal()     # Just epoch progress
config = LogConfig.standard()    # Layer info + timing + health checks
config = LogConfig.verbose()     # Full math depth -- every formula, every gradient
config = LogConfig.research()    # Everything + export to files

model.compile(loss="mse", optimizer="adam", log_config=config)

config = LogConfig.research()
config.export_formats = ["json", "csv", "html", "markdown"]
config.export_dir = "./my_training_logs"

model.compile(loss="mse", optimizer="adam", log_config=config)
model.fit(X, y, epochs=50)

# After training, find in ./my_training_logs/:
#   training_log.json   -- Full structured event log
#   metrics.csv         -- Epoch-level metrics table
#   report.html         -- Interactive HTML report with Chart.js graphs
#   report.md           -- Human-readable Markdown report

from neurogebra.logging.adaptive import AdaptiveLogger, AnomalyConfig
from neurogebra.logging.logger import TrainingLogger, LogLevel

base_logger = TrainingLogger(level=LogLevel.EXPERT)
adaptive = AdaptiveLogger(base_logger, config=AnomalyConfig(
    zeros_pct_threshold=50.0,
    gradient_spike_factor=5.0,
    escalation_cooldown=10,
))
# Stays at BASIC until anomaly detected, then escalates automatically

from neurogebra.logging.health_warnings import AutoHealthWarnings, WarningConfig

warnings_engine = AutoHealthWarnings(config=WarningConfig(
    dead_relu_zeros_pct=50.0,
    overfit_patience=3,
    overfit_ratio=1.3,
))
# 10 built-in rules: dead_relu, vanishing/exploding gradient, NaN/Inf,
# overfitting, loss stagnation, weight stagnation, loss divergence, activation saturation

from neurogebra.logging.dashboard import DashboardExporter

dashboard = DashboardExporter(path="training_logs/dashboard.html")
logger.add_backend(dashboard)
# Generates self-contained HTML with loss curves, accuracy charts,
# timing bars, batch-level metrics, and health diagnostics

from neurogebra.logging.fingerprint import TrainingFingerprint

fp = TrainingFingerprint.capture(
    model_info={"name": "my_model", "layers": 3},
    hyperparameters={"lr": 0.01, "batch_size": 32, "epochs": 50},
    dataset=X_train,
    random_seed=42,
)
print(fp.format_text())
# Captures: seeds, dataset SHA-256, library versions, CPU/RAM/GPU, OS, git state

import numpy as np

# Core
from neurogebra.builders.model_builder import ModelBuilder
from neurogebra.datasets.loaders import Datasets

# Observatory (base logging)
from neurogebra.logging.logger import TrainingLogger, LogLevel
from neurogebra.logging.config import LogConfig

# Observatory Pro
from neurogebra.logging.adaptive import AdaptiveLogger, AnomalyConfig
from neurogebra.logging.health_warnings import AutoHealthWarnings, WarningConfig
from neurogebra.logging.epoch_summary import EpochSummarizer
from neurogebra.logging.tiered_storage import TieredStorage
from neurogebra.logging.dashboard import DashboardExporter
from neurogebra.logging.fingerprint import TrainingFingerprint

# Load a synthetic dataset
X, y = Datasets.load_moons(n_samples=1000, noise=0.2)

# Train/test split
split = int(0.8 * len(X))
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

print(f"Training samples: {X_train.shape[0]}")
print(f"Test samples:     {X_test.shape[0]}")
print(f"Features:         {X_train.shape[1]}")

builder = ModelBuilder()
model = builder.Sequential([
    builder.Dense(64, activation="relu", input_shape=(2,)),
    builder.Dense(32, activation="tanh"),
    builder.Dense(1, activation="sigmoid"),
], name="moon_classifier")

# Inspect before training
model.summary()
model.explain_architecture()

# Base logger at EXPERT level
base_logger = TrainingLogger(level=LogLevel.EXPERT)

# Adaptive wrapper -- stays quiet until something goes wrong
adaptive = AdaptiveLogger(base_logger, config=AnomalyConfig(
    zeros_pct_threshold=50.0,      # Dead neuron threshold
    gradient_spike_factor=5.0,     # Gradient spike sensitivity
    escalation_cooldown=10,        # Stay escalated for 10 events
))

# Tiered storage -- separates logs into basic/health/debug files
storage = TieredStorage(
    base_dir="./training_logs",
    write_debug=True,
    buffer_size=50,
)
base_logger.add_backend(storage)

# Interactive HTML dashboard
dashboard = DashboardExporter(path="./training_logs/dashboard.html")
base_logger.add_backend(dashboard)

# Health warnings engine
warnings_engine = AutoHealthWarnings(config=WarningConfig(
    dead_relu_zeros_pct=50.0,
    overfit_patience=3,
    overfit_ratio=1.3,
))

# Epoch summarizer
summarizer = EpochSummarizer()

fingerprint = TrainingFingerprint.capture(
    model_info={"name": "moon_classifier", "layers": 3},
    hyperparameters={
        "learning_rate": 0.01,
        "batch_size": 32,
        "epochs": 20,
        "optimizer": "adam",
        "loss": "binary_crossentropy",
    },
    dataset=X_train,
    random_seed=42,
)

print(fingerprint.format_text())
# Output:
# +-- Training Fingerprint --+
#   Run ID:       a1b2c3d4e5f6
#   Timestamp:    2026-03-01 12:00:00
#   Seed:         42
#   Dataset Hash: 8f14e45fceea167a
#   Neurogebra:   2.5.3
#   Python:       3.11.5
#   NumPy:        1.26.0
#   ...
# +-------------------------+

# Compile with Observatory logging enabled
model.compile(
    loss="binary_crossentropy",
    optimizer="adam",
    learning_rate=0.01,
    log_level="expert",
)

# Run training
epochs = 20
batch_size = 32
num_batches = len(X_train) // batch_size

adaptive.on_train_start(total_epochs=epochs, model_info=fingerprint.model_info)

for epoch in range(epochs):
    adaptive.on_epoch_start(epoch)
    epoch_loss = 0.0

    for batch_idx in range(num_batches):
        start = batch_idx * batch_size
        end = start + batch_size
        X_batch = X_train[start:end]
        y_batch = y_train[start:end]

        # Forward pass (real computation)
        predictions = model.predict(X_batch)
        loss = np.mean((predictions.flatten() - y_batch) ** 2)
        epoch_loss += loss

        # Record batch metrics
        summarizer.record_batch(
            epoch=epoch,
            metrics={"loss": loss, "accuracy": np.mean((predictions.flatten() > 0.5) == y_batch)},
        )

        # Check batch-level health
        batch_alerts = warnings_engine.check_batch(
            epoch=epoch,
            batch=batch_idx,
            loss=loss,
        )
        for alert in batch_alerts:
            print(f"  [{alert.severity.upper()}] {alert.message}")

    # Epoch summary
    avg_loss = epoch_loss / num_batches
    summary = summarizer.finalize_epoch(epoch)
    print(summary.format_text())

    # Epoch-level health check
    epoch_alerts = warnings_engine.check_epoch(
        epoch=epoch,
        train_loss=avg_loss,
    )

    adaptive.on_epoch_end(epoch, metrics={"loss": avg_loss})

adaptive.on_train_end()

# Flush and close storage
storage.flush()
storage.close()

# Save dashboard
dashboard.save()

# Save fingerprint
import json
with open("./training_logs/fingerprint.json", "w") as f:
    json.dump(fingerprint.to_dict(), f, indent=2)

# Print summary
print(f"\nAnomalies detected: {adaptive.get_anomaly_summary()['total_anomalies']}")
print(f"Health warnings:    {warnings_engine.get_summary()['total_warnings']}")
print(f"\nFiles saved to ./training_logs/:")
print(f"  basic.log        -- Epoch-level metrics (NDJSON)")
print(f"  health.log       -- Health warnings and anomalies (NDJSON)")
print(f"  debug.log        -- Full expert-level detail (NDJSON)")
print(f"  dashboard.html   -- Interactive HTML dashboard")
print(f"  fingerprint.json -- Full reproducibility snapshot")

from neurogebra.datasets import Datasets

Datasets.list_all()                                           # Browse all
(X_train, y_train), (X_test, y_test) = Datasets.load_iris()  # Load
Datasets.search("classification")                             # Search
Datasets.get_info("california_housing")                       # Details

from neurogebra.builders.model_builder import ModelBuilder
from neurogebra.training.educational_trainer import EducationalTrainer
from neurogebra.datasets.loaders import Datasets
import numpy as np

X, y = Datasets.load_moons(n_samples=500, noise=0.2)

builder = ModelBuilder()
model = builder.Sequential([
    builder.Dense(64, activation="relu", input_shape=(2,)),
    builder.Dropout(0.2),
    builder.Dense(32, activation="relu"),
    builder.Dense(1, activation="sigmoid")
], name="moon_classifier")

model.summary()
model.explain_architecture()
model.compile(optimizer="adam", loss="binary_crossentropy", learning_rate=0.01)

trainer = EducationalTrainer(model, verbose=True, explain_steps=True)
history = trainer.train(X, y, epochs=20, batch_size=32, validation_split=0.2)

from neurogebra import Expression
from neurogebra.core.trainer import Trainer
import numpy as np

expr = Expression(
    "fit_line", "m*x + b",
    params={"m": 0.0, "b": 0.0},
    trainable_params=["m", "b"]
)

X = np.linspace(0, 10, 100)
y = 2 * X + 1 + np.random.normal(0, 0.5, 100)

trainer = Trainer(expr, learning_rate=0.01, optimizer="adam")
history = trainer.fit(X, y, epochs=200, verbose=True)
print(f"Learned: m={expr.params['m']:.2f}, b={expr.params['b']:.2f}")
# Output: Learned: m=2.00, b=1.01

from neurogebra import MathForge

forge = MathForge()

sigmoid = forge.get("sigmoid")
sigmoid_grad = sigmoid.gradient("x")
print(sigmoid_grad.formula)   # Analytical derivative in LaTeX

mse = forge.get("mse")
mae = forge.get("mae")
custom_loss = 0.7 * mse + 0.3 * mae
print(custom_loss.eval(y=1.0, y_pred=0.8))

from neurogebra.core.autograd import Value

x = Value(2.0)
w = Value(-3.0)
b = Value(1.0)

y = w * x + b
z = y.relu()
z.backward()

print(f"dz/dw = {w.grad}")   # 2.0
print(f"dz/dx = {x.grad}")   # -3.0

from neurogebra.bridges import to_pytorch, to_tensorflow

# Export to PyTorch
pytorch_model = to_pytorch(model)

# Export to TensorFlow/Keras
tf_model = to_tensorflow(model)