Getting Started with MindsEye

1. Basic Feedforward Network (MNIST Classification)

import com.simiacryptus.mindseye.network.PipelineNetwork;
import com.simiacryptus.mindseye.layers.java.*;
import com.simiacryptus.mindseye.opt.*;

// Create a basic feedforward network for MNIST digit classification
PipelineNetwork network = new PipelineNetwork(1)
    .add(new DenseLayer(784, 128))      // Input: 28x28 pixels = 784
    .add(new ReLuActivationLayer())     // ReLU activation
    .add(new DenseLayer(128, 64))       // Hidden layer
    .add(new ReLuActivationLayer())
    .add(new DenseLayer(64, 10))        // Output: 10 digit classes
    .add(new SoftmaxActivationLayer()); // Softmax for classification

// Load and prepare training data
Tensor[][] trainingData = loadMNISTData(); // Your data loading method

// Configure comprehensive training monitoring
TrainingMonitor monitor = new TrainingMonitor()
    .setLogLevel(Level.INFO)
    .setMaxIterations(1000)
    .setIterationsPerSample(100)        // Log every 100 iterations
    .setTimeoutMinutes(30);             // 30-minute timeout

// Set up L-BFGS optimizer with monitoring
IterativeTrainer trainer = new IterativeTrainer(network)
    .setOrienter(new LBFGS())
    .setMonitor(monitor)
    .setTimeout(10, TimeUnit.MINUTES);

// Start training
trainer.run();

// Evaluate the trained model
double accuracy = evaluateAccuracy(network, testData);
System.out.println("Test Accuracy: " + accuracy + "%");

2. Convolutional Neural Network (Image Classification)

// Create a CNN for advanced image classification
PipelineNetwork cnn = new PipelineNetwork(1)
    // First convolutional block
    .add(new ConvolutionLayer(5, 5, 3, 32))     // 5x5 kernel, RGB->32 channels
    .add(new ReLuActivationLayer())
    .add(new PoolingLayer().setMode(PoolingLayer.PoolingMode.Max))
    
    // Second convolutional block
    .add(new ConvolutionLayer(5, 5, 32, 64))    // 32->64 channels
    .add(new ReLuActivationLayer())
    .add(new PoolingLayer().setMode(PoolingLayer.PoolingMode.Max))
    
    // Fully connected layers
    .add(new DenseLayer(1024, 512))             // Flatten and dense
    .add(new DropoutLayer(0.5))                 // Regularization
    .add(new DenseLayer(512, 10))               // Final classification
    .add(new SoftmaxActivationLayer());

// Advanced training configuration
IterativeTrainer cnnTrainer = new IterativeTrainer(cnn)
    .setOrienter(new AdamOptimizer(0.001))      // Adam with learning rate
    .setMonitor(new TrainingMonitor()
        .setMaxIterations(5000)
        .setValidationData(validationSet))      // Include validation
    .setTimeout(2, TimeUnit.HOURS);             // Longer training time

cnnTrainer.run();

3. GPU Acceleration Setup

// Initialize CUDA system (requires CUDA installation)
CudaSystem.initialize();

// Enable GPU acceleration for the network
network.setParallel(true);

// Configure memory and precision settings
network.setPrecision(Precision.Float);          // Use 32-bit for speed
CudaMemory.setDefaultMemoryMode(CudaMemory.MemoryMode.Managed);

// Monitor GPU memory usage
CudaMemory.addMemoryHandler(new CudaMemory.MemoryHandler() {
    @Override
    public void handle(CudaMemory.MemoryInfo info) {
        System.out.println("GPU Memory: " + info.getUsedMemory() + "/" + info.getTotalMemory());
    }
});

// Multi-GPU configuration (if available)
CudaSystem.setDefaultDevice(0);                 // Use first GPU
// CudaSystem.setDefaultDevice(1);              // Switch to second GPU

4. Advanced Features & Customization

// Custom loss functions
network.setLossFunction(new MeanSquaredError());
// network.setLossFunction(new CrossEntropyLoss());
// network.setLossFunction(new HingeLoss());

// Advanced optimizers with scheduling
AdamOptimizer adam = new AdamOptimizer()
    .setLearningRate(0.001)
    .setBeta1(0.9)
    .setBeta2(0.999)
    .setEpsilon(1e-8);

// Learning rate scheduling
trainer.setOrienter(new ScheduledOptimizer(adam)
    .addSchedule(1000, 0.0005)                  // Reduce LR after 1000 iterations
    .addSchedule(3000, 0.0001));                // Further reduce after 3000

// Model persistence
network.writeToFile(new File("trained_model.json"));

// Load pre-trained model
PipelineNetwork loadedNetwork = PipelineNetwork.fromFile(new File("trained_model.json"));

// Export to different formats
network.exportToONNX("model.onnx");            // ONNX format
network.exportToTensorFlow("model.pb");        // TensorFlow format

5. Unique MindsEye Features

Input Learning (Modify Training Data)

// Enable input learning to optimize training data itself
InputLearningTrainer inputTrainer = new InputLearningTrainer(network)
    .setInputLearningRate(0.01)
    .setDataAugmentation(true);

inputTrainer.run(trainingData);

Deep Dream Implementation

// Create artistic visualizations
DeepDreamNetwork dreamNet = new DeepDreamNetwork(pretrainedVGG)
    .setTargetLayer("conv4_1")
    .setIterations(100)
    .setLearningRate(0.01);

Tensor dreamImage = dreamNet.process(inputImage);

A/B Testing Framework

// Compare different architectures
ABTestFramework abTest = new ABTestFramework()
    .addModel("ModelA", networkA)
    .addModel("ModelB", networkB)
    .setTestData(testSet)
    .setSignificanceLevel(0.05);

ABTestResult result = abTest.run();
System.out.println("Winner: " + result.getBestModel());
System.out.println("Confidence: " + result.getConfidence());

6. Monitoring & Debugging

// Comprehensive monitoring setup
TrainingMonitor advancedMonitor = new TrainingMonitor()
    .setLogLevel(Level.DEBUG)
    .addMetric("loss", new LossMetric())
    .addMetric("accuracy", new AccuracyMetric())
    .addMetric("gradient_norm", new GradientNormMetric())
    .setPlotting(true)                          // Generate training plots
    .setNotebookOutput("training_log.html");   // HTML report

// Real-time visualization
monitor.addVisualization(new NetworkVisualization(network));
monitor.addVisualization(new LossPlot());
monitor.addVisualization(new AccuracyPlot());

Pro Tips

Performance Optimization

• Use GPU acceleration for large models (>1M parameters)
• Enable mixed precision for 2x speed improvement
• Batch your data for optimal GPU utilization
• Monitor memory usage to prevent OOM errors

Debugging

• Enable finite difference validation during development
• Use smaller learning rates if training is unstable
• Add gradient clipping for RNN/LSTM networks
• Visualize network activations to debug dead neurons

Best Practices

• Always use validation data to prevent overfitting
• Implement early stopping based on validation loss
• Save model checkpoints during long training runs
• Use A/B testing to compare architectural changes