🚀 GRNexus v1.0

from grnexus import NeuralNetwork
from lib.grnexus_layers import DenseLayer
from lib.grnexus_activations import Tanh, Sigmoid

# XOR dataset
x_train = [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]]
y_train = [[0.0], [1.0], [1.0], [0.0]]

# Build model
model = NeuralNetwork(loss='mse', learning_rate=1.0)
model.add(DenseLayer(units=8, input_dim=2, activation=Tanh()))
model.add(DenseLayer(units=1, input_dim=8, activation=Sigmoid()))

# Train
model.train(x_train, y_train, epochs=5000, batch_size=4, verbose=False)

# Save (works in Ruby too!)
model.save('xor_model.nexus')

# Predict
print(f"{model.predict([[0.0, 0.0]])[0][0]:.2f}")  # => ~0.0
print(f"{model.predict([[1.0, 1.0]])[0][0]:.2f}")  # => ~0.0
print(f"{model.predict([[0.0, 1.0]])[0][0]:.2f}")  # => ~1.0
print(f"{model.predict([[1.0, 0.0]])[0][0]:.2f}")  # => ~1.0

from grnexus import NeuralNetwork
from lib.grnexus_text_proccessing import Vocabulary, TextVectorizer
from lib.grnexus_layers import DenseLayer, DropoutLayer
from lib.grnexus_activations import ReLU, Tanh
from lib.grnexus_normalization import Softmax

# Training data
texts = [
    "I love this product it's excellent",
    "terrible product very bad quality",
    "amazing quality exceeded expectations",
    "worst purchase ever disappointed",
    "highly recommend great value",
    "waste of money poor quality"
]
labels = [[1, 0], [0, 1], [1, 0], [0, 1], [1, 0], [0, 1]]  # [positive, negative]

# Create vocabulary and vectorize
vocab = Vocabulary(texts, max_vocab_size=100)
vectorizer = TextVectorizer(vocab)
x_train = [vectorizer.vectorize(text) for text in texts]

# Build sentiment analyzer
model = NeuralNetwork(loss='cross_entropy', learning_rate=0.05, name='sentiment_analyzer')
model.add(DenseLayer(32, vocab.size, activation=ReLU()))
model.add(DropoutLayer(rate=0.3))
model.add(DenseLayer(16, 32, activation=Tanh()))
model.add(DenseLayer(2, 16, activation=Softmax()))

# Train
model.train(x_train, labels, epochs=100, batch_size=2, verbose=True)

# Test predictions
test_text = "excellent product very good"
test_vector = vectorizer.vectorize(test_text)
prediction = model.predict([test_vector])[0]
sentiment = "POSITIVE" if prediction[0] > prediction[1] else "NEGATIVE"
confidence = max(prediction) * 100

print(f"Text: '{test_text}'")
print(f"Sentiment: {sentiment} ({confidence:.2f}% confidence)")

# Save for Ruby
model.save('models/sentiment_analyzer.nexus')

from grnexus import NeuralNetwork
from lib.grnexus_text_proccessing import Vocabulary, TextEmbeddings
from lib.grnexus_layers import EmbeddingLayer, DenseLayer, DropoutLayer, FlattenLayer
from lib.grnexus_activations import ReLU
from lib.grnexus_normalization import Softmax

# Larger dataset
texts = [
    "This movie is absolutely fantastic and amazing",
    "Terrible film waste of time and money",
    "Great acting superb storyline loved it",
    "Boring predictable disappointing experience",
    # ... more training data
]
labels = [[1, 0], [0, 1], [1, 0], [0, 1]]  # [positive, negative]

# Create vocabulary
vocab = Vocabulary(texts, max_vocab_size=5000)

# Normalize texts to sequences of indices
max_length = 20
x_train = [vocab.normalize_text(text, max_length=max_length) for text in texts]

# Build model with embedding layer
model = NeuralNetwork(loss='cross_entropy', learning_rate=0.001, name='sentiment_embeddings')

# Embedding layer converts word indices to dense vectors
model.add(EmbeddingLayer(
    vocab_size=vocab.size,
    embedding_dim=128,
    input_length=max_length
))

# Flatten embeddings
model.add(FlattenLayer())  # Output: max_length * embedding_dim

# Dense layers
model.add(DenseLayer(64, max_length * 128, activation=ReLU()))
model.add(DropoutLayer(rate=0.5))
model.add(DenseLayer(32, 64, activation=ReLU()))
model.add(DenseLayer(2, 32, activation=Softmax()))

# Train
model.train(x_train, labels, epochs=50, batch_size=16, verbose=True)

# Predict
test_text = "amazing movie highly recommended"
test_seq = vocab.normalize_text(test_text, max_length=max_length)
prediction = model.predict([test_seq])[0]
print(f"Sentiment: {'POSITIVE' if prediction[0] > prediction[1] else 'NEGATIVE'}")
print(f"Confidence: {max(prediction)*100:.2f}%")

model.save('sentiment_embeddings.nexus')

# Load Ruby model in Python
model = NeuralNetwork.load('sentiment_embeddings.nexus')
# => Loading model: GRNexus v1.0 (created in Ruby)

# Use it immediately!
prediction = model.predict(test_data)
print(f"Sentiment: {'POSITIVE' if prediction[0] > prediction[1] else 'NEGATIVE'}")

# Team B: Python developers use it
model = NeuralNetwork.load('shared_model.nexus')
# => Loading model: GRNexus v1.0 (created in Ruby)
#    Total params: 6,538
#    Layers: 3

# Continue training with new data
model.train(new_x, new_y, epochs=20)

# Deploy in production
predictions = model.predict(production_data)

from grnexus import NeuralNetwork
from lib.grnexus_layers import DenseLayer, DropoutLayer
from lib.grnexus_activations import ReLU, Sigmoid
from lib.grnexus_normalization import Softmax

# Create simple network with dropout
model = NeuralNetwork(learning_rate=0.1)

# Hidden layer with ReLU
model.add(DenseLayer(units=4, input_dim=2, activation=ReLU()))

# Output layer with Sigmoid
model.add(DenseLayer(units=1, input_dim=4, activation=Sigmoid()))

# XOR problem
x_train = [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]]
y_train = [[0.0], [1.0], [1.0], [0.0]]

# Train
model.compile(loss='mse')
model.train(x_train, y_train, epochs=100, batch_size=4, verbose=False)

# Predict
predictions = model.predict(x_train)
for i, x in enumerate(x_train):
    print(f"Input: {x} -> Predicted: {predictions[i][0]:.2f}, Target: {y_train[i][0]}")

from grnexus import NeuralNetwork
from lib.grnexus_layers import DenseLayer, DropoutLayer
from lib.grnexus_activations import ReLU
from lib.grnexus_normalization import Softmax

# Binary classification with dropout
model = NeuralNetwork(learning_rate=0.01)
model.add(DenseLayer(units=8, input_dim=3, activation=ReLU()))
model.add(DropoutLayer(rate=0.3))  # Drop 30% during training
model.add(DenseLayer(units=4, input_dim=8, activation=ReLU()))
model.add(DropoutLayer(rate=0.2))  # Drop 20% during training
model.add(DenseLayer(units=2, input_dim=4, activation=Softmax()))

# Training data
x_train = [
    [1.0, 2.0, 3.0], [1.5, 2.5, 3.5], [1.2, 2.2, 3.2],
    [5.0, 6.0, 7.0], [5.5, 6.5, 7.5], [5.2, 6.2, 7.2]
]
y_train = [
    [1.0, 0.0], [1.0, 0.0], [1.0, 0.0],
    [0.0, 1.0], [0.0, 1.0], [0.0, 1.0]
]

model.compile(loss='cross_entropy')
model.train(x_train, y_train, epochs=50, batch_size=2, verbose=False)

# Predict (dropout automatically disabled during inference)
predictions = model.predict(x_train)
for i, pred in enumerate(predictions):
    pred_class = pred.index(max(pred))
    target_class = y_train[i].index(max(y_train[i]))
    print(f"Sample {i + 1}: Predicted class {pred_class}, Target class {target_class}")

from grnexus import NeuralNetwork
from lib.grnexus_layers import DenseLayer, BatchNormLayer, ActivationLayer
from lib.grnexus_activations import ReLU
from lib.grnexus_normalization import Softmax

# Multi-class classification with BatchNorm
model = NeuralNetwork(learning_rate=0.01)

# Layer 1: Dense + BatchNorm + Activation
model.add(DenseLayer(units=16, input_dim=4, activation=None))  # No activation yet
model.add(BatchNormLayer(epsilon=1e-5, momentum=0.1))
model.add(ActivationLayer(ReLU()))

# Layer 2: Dense + BatchNorm + Activation
model.add(DenseLayer(units=8, input_dim=16, activation=None))
model.add(BatchNormLayer(epsilon=1e-5, momentum=0.1))
model.add(ActivationLayer(ReLU()))

# Output layer
model.add(DenseLayer(units=3, input_dim=8, activation=Softmax()))

# Multi-class data (3 classes)
x_train = [
    [1.0, 1.0, 1.0, 1.0], [1.2, 1.1, 1.3, 1.0],
    [3.0, 3.0, 3.0, 3.0], [3.2, 3.1, 3.3, 3.0],
    [5.0, 5.0, 5.0, 5.0], [5.2, 5.1, 5.3, 5.0]
]
y_train = [
    [1.0, 0.0, 0.0], [1.0, 0.0, 0.0],
    [0.0, 1.0, 0.0], [0.0, 1.0, 0.0],
    [0.0, 0.0, 1.0], [0.0, 0.0, 1.0]
]

model.compile(loss='cross_entropy')
model.train(x_train, y_train, epochs=100, batch_size=2, verbose=False)

# Test predictions
predictions = model.predict(x_train)
correct = 0
for i, pred in enumerate(predictions):
    pred_class = pred.index(max(pred))
    target_class = y_train[i].index(max(y_train[i]))
    if pred_class == target_class:
        correct += 1
    print(f"Sample {i + 1}: Predicted class {pred_class}, Target class {target_class}")

accuracy = (correct / len(y_train) * 100)
print(f"\nAccuracy: {accuracy:.2f}%")

from grnexus import NeuralNetwork
from lib.grnexus_layers import DenseLayer, BatchNormLayer, DropoutLayer, ActivationLayer
from lib.grnexus_activations import ReLU, Tanh
from lib.grnexus_normalization import Softmax
import random

# Complex network combining all layer types
model = NeuralNetwork(learning_rate=0.01, name='ComplexModel')

# Input layer with BatchNorm and Dropout
model.add(DenseLayer(units=32, input_dim=5, activation=None))
model.add(BatchNormLayer())
model.add(ActivationLayer(ReLU()))
model.add(DropoutLayer(rate=0.3))

# Hidden layer 1
model.add(DenseLayer(units=16, input_dim=32, activation=None))
model.add(BatchNormLayer())
model.add(ActivationLayer(ReLU()))
model.add(DropoutLayer(rate=0.2))

# Hidden layer 2
model.add(DenseLayer(units=8, input_dim=16, activation=Tanh()))

# Output layer
model.add(DenseLayer(units=2, input_dim=8, activation=Softmax()))

# View architecture
print("\nModel Summary:")
model.summary()

# Generate synthetic data
x_train = []
y_train = []
for i in range(20):
    if i < 10:
        x_train.append([random.uniform(0.0, 2.0) for _ in range(5)])
        y_train.append([1.0, 0.0])
    else:
        x_train.append([random.uniform(5.0, 7.0) for _ in range(5)])
        y_train.append([0.0, 1.0])

# Train
model.compile(loss='cross_entropy')
history = model.train(x_train, y_train, epochs=50, batch_size=4, verbose=False)

print(f"\nFinal training loss: {history['loss'][-1]:.4f}")
if history.get('accuracy'):
    print(f"Final training accuracy: {history['accuracy'][-1]:.2f}%")

# Save and load model
filepath = 'complex_model.nexus'
model.save(filepath)
print(f"\n✓ Model saved to {filepath}")

loaded_model = NeuralNetwork.load(filepath)
print("✓ Model loaded successfully")

# Verify predictions match
test_sample = [x_train[0]]
pred_original = model.predict(test_sample)
pred_loaded = loaded_model.predict(test_sample)

print("\nVerifying loaded model predictions match...")
for i, val in enumerate(pred_original[0]):
    error = abs(val - pred_loaded[0][i])
    assert error < 0.001, "Predictions don't match!"
print("✓ Predictions match!")

from grnexus import NeuralNetwork
from lib.grnexus_layers import DenseLayer, BatchNormLayer, DropoutLayer
from lib.grnexus_activations import GELU, Swish, Mish, SELU
from lib.grnexus_normalization import Softmax

# Create a state-of-the-art deep network
model = NeuralNetwork(
    loss='mse',
    optimizer='adam',
    learning_rate=0.001,
    name='deep_network'
)

# Layer 1: GELU activation (used in GPT, BERT)
model.add(DenseLayer(units=128, input_dim=20, activation=GELU()))
model.add(BatchNormLayer())

# Layer 2: Swish activation (Google's discovery)
model.add(DenseLayer(units=96, input_dim=128, activation=Swish()))
model.add(DropoutLayer(rate=0.2))

# Layer 3: Mish activation (state-of-the-art)
model.add(DenseLayer(units=64, input_dim=96, activation=Mish()))
model.add(BatchNormLayer())

# Layer 4: SELU (self-normalizing)
model.add(DenseLayer(units=32, input_dim=64, activation=SELU()))

# Output layer
model.add(DenseLayer(units=5, input_dim=32, activation=Softmax()))

# View architecture
model.summary()

# Train
history = model.train(x_train, y_train, epochs=50, batch_size=32, verbose=True)

# Save
model.save('models/deep_network.nexus')

from grnexus import NeuralNetwork
from lib.grnexus_layers import DenseLayer
from lib.grnexus_activations import Tanh, ReLU
from lib.grnexus_numeric_proccessing import MovingAverage, ZScoreNormalize
import math
import random

# Generate time series
time_series = [math.sin(i * 0.05) * 10 + random.random() * 2 for i in range(200)]

# Preprocess
ma = MovingAverage(window_size=5)
smoothed = ma.process(time_series)

zscore = ZScoreNormalize()
normalized = zscore.process(smoothed)

# Create sliding windows
window_size = 10
x_train = []
y_train = []

for i in range(len(normalized) - window_size - 1):
    x_train.append(normalized[i:i+window_size])
    y_train.append([normalized[i + window_size]])

# Build model
ts_model = NeuralNetwork(loss='mse', learning_rate=0.01)
ts_model.add(DenseLayer(64, window_size, activation=Tanh()))
ts_model.add(DenseLayer(32, 64, activation=ReLU()))
ts_model.add(DenseLayer(1, 32))

ts_model.train(x_train, y_train, epochs=50, batch_size=16)
ts_model.save('time_series_model.nexus')

# Make predictions
future_window = normalized[-window_size:]
prediction = ts_model.predict([future_window])[0]
print(f"Next value prediction: {prediction[0]:.4f}")

from grnexus import NeuralNetwork
from lib.grnexus_layers import *
from lib.grnexus_activations import ReLU
from lib.grnexus_normalization import Softmax

# Build CNN for MNIST-like image classification (28x28 grayscale)
model = NeuralNetwork(
    loss='cross_entropy',
    optimizer='adam',
    learning_rate=0.001,
    name='mnist_classifier'
)

# First convolutional block
model.add(Conv2DLayer(
    filters=32,
    kernel_size=3,
    input_shape=(28, 28, 1),  # 28x28 grayscale images
    activation=ReLU(),
    padding='same'
))
model.add(MaxPoolingLayer(pool_size=2, stride=2))  # Output: 14x14x32

# Second convolutional block
model.add(Conv2DLayer(
    filters=64,
    kernel_size=3,
    activation=ReLU(),
    padding='same'
))
model.add(MaxPoolingLayer(pool_size=2, stride=2))  # Output: 7x7x64

# Third convolutional block (optional, for deeper networks)
model.add(Conv2DLayer(
    filters=128,
    kernel_size=3,
    activation=ReLU(),
    padding='same'
))

# Flatten and dense layers
model.add(FlattenLayer())  # Flatten to 1D: 7x7x128 = 6272
model.add(DenseLayer(
    units=256,
    input_dim=6272,
    activation=ReLU()
))
model.add(DropoutLayer(rate=0.5))  # Regularization
model.add(DenseLayer(
    units=10,
    input_dim=256,
    activation=Softmax()  # 10 classes (digits 0-9)
))

# View architecture
model.summary()

# Prepare data (example with random data)
import random
x_train = [[[random.random() for _ in range(28)] for _ in range(28)] for _ in range(1000)]
y_train = []
for _ in range(1000):
    label = random.randint(0, 9)
    y_train.append([1.0 if i == label else 0.0 for i in range(10)])

# Train
history = model.train(
    x_train, y_train,
    epochs=20,
    batch_size=32,
    verbose=True
)

# Save model
model.save('models/mnist_cnn.nexus')

# Evaluate
x_test = [[[random.random() for _ in range(28)] for _ in range(28)] for _ in range(200)]
y_test = []
for _ in range(200):
    label = random.randint(0, 9)
    y_test.append([1.0 if i == label else 0.0 for i in range(10)])

loss, accuracy = model.evaluate(x_test, y_test)
print(f"Test Accuracy: {accuracy:.2f}%")

# Predict single image
single_image = [[random.random() for _ in range(28)] for _ in range(28)]
prediction = model.predict([single_image])[0]
predicted_digit = prediction.index(max(prediction))
print(f"Predicted digit: {predicted_digit} (confidence: {max(prediction)*100:.2f}%)")

# For RGB images (e.g., 32x32x3 CIFAR-10 style)
model = NeuralNetwork(loss='cross_entropy', learning_rate=0.001)

# Input: 32x32x3 (RGB)
model.add(Conv2DLayer(filters=32, kernel_size=3, input_shape=(32, 32, 3), activation=ReLU()))
model.add(Conv2DLayer(filters=32, kernel_size=3, activation=ReLU()))
model.add(MaxPoolingLayer(pool_size=2))
model.add(DropoutLayer(rate=0.25))

model.add(Conv2DLayer(filters=64, kernel_size=3, activation=ReLU()))
model.add(Conv2DLayer(filters=64, kernel_size=3, activation=ReLU()))
model.add(MaxPoolingLayer(pool_size=2))
model.add(DropoutLayer(rate=0.25))

model.add(FlattenLayer())
model.add(DenseLayer(512, activation=ReLU()))
model.add(DropoutLayer(rate=0.5))
model.add(DenseLayer(10, activation=Softmax()))

# Train on RGB images
model.train(rgb_images, labels, epochs=50, batch_size=64)

from lib.grnexus_layers import MaxPoolingLayer

# Create pooling layer
pool_layer = MaxPoolingLayer(pool_size=2, stride=2)

# Example 1: Single 2D image (14x14)
single_image = [[random.random() * 10 for _ in range(14)] for _ in range(14)]
pooled_single = pool_layer.forward(single_image)
# Output shape: (7, 7) - reduced by factor of 2

# Example 2: Batch of 2D images (5 images of 14x14)
batch_images = [[[random.random() * 10 for _ in range(14)] for _ in range(14)] for _ in range(5)]
pooled_batch = pool_layer.forward(batch_images)
# Output shape: (5, 7, 7) - batch preserved, spatial dims reduced

# Example 3: After Conv2D layer
# Conv2D output is typically (batch, height, width, channels)
# You can pool each channel separately or reshape as needed

from grnexus import NeuralNetwork
from lib.grnexus_layers import LSTMLayer, FlattenLayer, DenseLayer
from lib.grnexus_normalization import Softmax

# Build LSTM network for sequence classification
model = NeuralNetwork(learning_rate=0.01)

# LSTM layer processes sequences
# Input shape: (batch_size, sequence_length, features)
# For example: [[1.0, 1.0, 1.0], [2.0, 2.0, 2.0], [3.0, 3.0, 3.0], ...]
model.add(LSTMLayer(units=8, input_size=3))

# Flatten LSTM output for dense layer
model.add(FlattenLayer())

# Output layer for classification
model.add(DenseLayer(units=2, input_dim=40, activation=Softmax()))

# Sequence data: [batch_size, sequence_length, features]
# Sequence 1: increasing pattern [1->5] -> class 0
# Sequence 2: decreasing pattern [5->1] -> class 1
x_train = [
    [[1.0, 1.0, 1.0], [2.0, 2.0, 2.0], [3.0, 3.0, 3.0], [4.0, 4.0, 4.0], [5.0, 5.0, 5.0]],
    [[5.0, 5.0, 5.0], [4.0, 4.0, 4.0], [3.0, 3.0, 3.0], [2.0, 2.0, 2.0], [1.0, 1.0, 1.0]]
]
y_train = [[1.0, 0.0], [0.0, 1.0]]

print("Training LSTM on sequence patterns...")
print("  Sequence 1: Increasing pattern [1->5]")
print("  Sequence 2: Decreasing pattern [5->1]")

model.compile(loss='cross_entropy')
model.train(x_train, y_train, epochs=30, batch_size=2, verbose=False)

# Predict
predictions = model.predict(x_train)
for i, pred in enumerate(predictions):
    pred_class = pred.index(max(pred))
    target_class = y_train[i].index(max(y_train[i]))
    pattern = "Increasing" if i == 0 else "Decreasing"
    print(f"  {pattern} sequence: Predicted class {pred_class}, Target class {target_class}")

model.save('lstm_model.nexus')

from grnexus import NeuralNetwork
from lib.grnexus_layers import GRULayer, FlattenLayer, DenseLayer
from lib.grnexus_normalization import Softmax

# GRU is faster and often performs similarly to LSTM
model = NeuralNetwork(learning_rate=0.01)

# GRU layer processes sequences
model.add(GRULayer(units=6, input_size=2))

# Flatten GRU output
model.add(FlattenLayer())

# Output layer
model.add(DenseLayer(units=2, input_dim=18, activation=Softmax()))

# Sequence data
x_train = [
    [[0.0, 0.0], [0.5, 0.5], [1.0, 1.0]],
    [[1.0, 1.0], [0.5, 0.5], [0.0, 0.0]]
]
y_train = [[1.0, 0.0], [0.0, 1.0]]

print("Training GRU on sequence patterns...")
model.compile(loss='cross_entropy')
model.train(x_train, y_train, epochs=30, batch_size=2, verbose=False)

predictions = model.predict(x_train)
for i, pred in enumerate(predictions):
    pred_class = pred.index(max(pred))
    print(f"  Sequence {i + 1}: Predicted class {pred_class}")

from grnexus import NeuralNetwork
from lib.grnexus_layers import EmbeddingLayer, FlattenLayer, DenseLayer
from lib.grnexus_activations import ReLU
from lib.grnexus_normalization import Softmax

# Create network with embedding layer
model = NeuralNetwork(learning_rate=0.01)

# Embedding layer: converts word indices to dense vectors
# vocab_size=10 means we have 10 unique words
# embedding_dim=4 means each word is represented by a 4D vector
model.add(EmbeddingLayer(vocab_size=10, embedding_dim=4))

# Flatten embeddings (input_length * embedding_dim)
model.add(FlattenLayer())

# Dense layers for classification
model.add(DenseLayer(units=8, input_dim=12, activation=ReLU()))
model.add(DenseLayer(units=2, input_dim=8, activation=Softmax()))

# Word indices as input (simulating tokenized text)
# Sequence 1: [1, 2, 3] -> class 0
# Sequence 2: [7, 8, 9] -> class 1
x_train = [
    [1.0, 2.0, 3.0],
    [7.0, 8.0, 9.0]
]
y_train = [[1.0, 0.0], [0.0, 1.0]]

print("Training with word embeddings...")
print("  Vocab size: 10, Embedding dim: 4")

model.compile(loss='cross_entropy')
model.train(x_train, y_train, epochs=30, batch_size=2, verbose=False)

predictions = model.predict(x_train)
for i, pred in enumerate(predictions):
    pred_class = pred.index(max(pred))
    print(f"  Word sequence {i + 1}: Predicted class {pred_class}")

from grnexus import NeuralNetwork
from lib.grnexus_layers import DenseLayer, BatchNormLayer, DropoutLayer
from lib.grnexus_activations import ReLU
from lib.grnexus_normalization import Softmax
from lib.grnexus_callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint

# Build model
model = NeuralNetwork(loss='cross_entropy', learning_rate=0.1, name='smart_model')
model.add(DenseLayer(64, 15, activation=ReLU()))
model.add(BatchNormLayer())
model.add(DropoutLayer(rate=0.3))
model.add(DenseLayer(32, 64, activation=ReLU()))
model.add(DenseLayer(4, 32, activation=Softmax()))

# Configure intelligent callbacks
callbacks = [
    # Stop training if validation loss doesn't improve for 5 epochs
    EarlyStopping(
        monitor='val_loss',
        patience=5,
        verbose=True,
        restore_best_weights=True
    ),
    
    # Reduce learning rate when validation loss plateaus
    ReduceLROnPlateau(
        monitor='val_loss',
        factor=0.5,
        patience=3,
        min_lr=0.0001,
        verbose=True
    ),
    
    # Save best model automatically
    ModelCheckpoint(
        filepath='models/best_model.nexus',
        monitor='val_loss',
        save_best_only=True,
        verbose=True
    )
]

# Train with intelligence
history = model.train(
    x_train, y_train,
    epochs=100,
    batch_size=32,
    validation_data=(x_val, y_val),
    callbacks=callbacks,
    verbose=True
)

# Output:
# Epoch 1/100 - Loss: 1.3862 - Accuracy: 25.00% - Val Loss: 1.3521 - Val Accuracy: 30.00%
# Epoch 1: val_loss improved to 1.3521, saving model to models/best_model.nexus
# ...
# Epoch 8: Reducing learning rate from 0.1 to 0.05
# ...
# Epoch 15: Reducing learning rate from 0.05 to 0.025
# ...
# Early stopping triggered at epoch 22
# Restoring best weights from epoch 17

print(f"Best validation loss: {min(history['val_loss'])}")
print(f"Training stopped at epoch: {len(history['loss'])}")

from grnexus import KNeighborsClassifier

# Movie ratings dataset: [action, comedy, drama, romance, sci-fi]
# Users who like action/sci-fi movies
user_ratings = [
    [5, 2, 1, 1, 4],  # User 1: Loves action & sci-fi
    [5, 1, 2, 1, 5],  # User 2: Loves action & sci-fi
    [4, 2, 1, 2, 5],  # User 3: Loves action & sci-fi
    [1, 5, 4, 5, 1],  # User 4: Loves comedy & romance
    [2, 5, 5, 4, 1],  # User 5: Loves comedy & romance
    [1, 4, 5, 5, 2],  # User 6: Loves comedy & romance
]

# User profiles: 0 = Action/Sci-Fi fan, 1 = Comedy/Romance fan
user_profiles = [0, 0, 0, 1, 1, 1]

# Train KNN recommender
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(user_ratings, user_profiles)

# New user rates movies
new_user = [[4, 3, 2, 2, 4]]  # Likes action & sci-fi more
profile = knn.predict(new_user)[0]

print(f"New user ratings: {new_user[0]}")
print(f"Recommended profile: {'Action/Sci-Fi' if profile == 0 else 'Comedy/Romance'}")
print(f"✓ Recommend: {'Action movies like Avengers, Star Wars' if profile == 0 else 'Comedies like The Hangover, Bridesmaids'}")

# Save for production
knn.save('movie_recommender.lnexus')

# Model info
print(f"\nModel: {knn}")
# Output: <KNeighborsClassifier n_neighbors=3, status=trained, samples=6, features=5>

from grnexus import KMeans

# Customer data: [monthly_spending, purchase_frequency]
customers = [
    # Low spenders, low frequency
    [50, 2], [60, 3], [55, 2], [45, 1], [52, 2], [48, 1],
    # Medium spenders, high frequency
    [200, 8], [220, 9], [210, 8], [195, 7], [215, 9], [205, 8],
    # High spenders, very high frequency (VIP)
    [500, 15], [520, 16], [510, 14], [495, 14], [530, 17], [505, 15]
]

# Segment customers into 3 groups
kmeans = KMeans(n_clusters=3, max_iter=100)
kmeans.fit(customers)

# Get cluster centers (average customer in each segment)
centers = kmeans.centroids
print("Customer Segments Identified:")
for i, center in enumerate(centers):
    spending, frequency = center
    
    if spending < 100:
        segment = "Occasional Shoppers"
        strategy = "Send discount coupons to increase engagement"
    elif spending < 300:
        segment = "Regular Customers"
        strategy = "Loyalty program and exclusive offers"
    else:
        segment = "VIP Customers"
        strategy = "Personal attention and early access to products"
    
    print(f"\n  Segment {i + 1}: {segment}")
    print(f"    Avg Monthly Spending: ${spending:.2f}")
    print(f"    Avg Purchase Frequency: {frequency:.1f} times/month")
    print(f"    Marketing Strategy: {strategy}")

# Classify new customers
new_customers = [
    [180, 7],   # Should be Regular
    [550, 18],  # Should be VIP
    [40, 1]     # Should be Occasional
]
segments = kmeans.predict(new_customers)

print("\nNew Customer Classification:")
for i, (customer, segment) in enumerate(zip(new_customers, segments)):
    print(f"  Customer {i + 1}: Spending=${customer[0]}, Frequency={customer[1]} → Segment {segment + 1}")

# Save for production
kmeans.save('customer_segmentation.lnexus')

print(f"\n✓ Model: {kmeans}")
# Output: <KMeans n_clusters=3, status=trained, features=2>