Runtime Variables & True Resume Platform Contract

┌───────────────────────────────────────────────────────────────────────────┐
│                      CONTAINER RUNTIME ENVIRONMENT                        │
│                                                                           │
│   $USER_WORKSPACE  ────────► /workspace (Root user folder)                │
│   $DATASET_DIR     ────────► /workspace/datasets (Read training data)     │
│   $CHECKPOINT_DIR  ────────► /workspace/checkpoints (Save epoch states)   │
│   $JOB_OUTPUT_DIR  ────────► /workspace/output (Save final metrics/logs)  │
│   $CODE_DIR        ────────► /workspace/code (Supporting user modules)    │
│                                                                           │
│   $COMPUTEAI_RESUME_EPOCH  ──► Starting epoch integer (0 if fresh run)    │
│   resume_epoch             ──► Injected global variable for quick access  │
└───────────────────────────────────────────────────────────────────────────┘

# Check global namespace injected by platform, then OS environment, then fallback to 0
start_epoch = int(globals().get("resume_epoch", os.getenv("COMPUTEAI_RESUME_EPOCH", 0)))

import os
import torch
import torch.nn as nn
import torch.optim as optim

def main():
    # 1. Workspace and Directory Resolution
    workspace = os.getenv("USER_WORKSPACE", "./workspace")
    dataset_dir = os.getenv("DATASET_DIR", os.path.join(workspace, "datasets"))
    checkpoint_dir = os.getenv("CHECKPOINT_DIR", os.path.join(workspace, "checkpoints"))
    output_dir = os.getenv("JOB_OUTPUT_DIR", os.path.join(workspace, "outputs"))

    os.makedirs(checkpoint_dir, exist_ok=True)
    os.makedirs(output_dir, exist_ok=True)

    # 2. Select Compute Device (GPU if available)
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"Using compute device: {device}")

    # 3. Define Model, Loss, Optimizer
    model = nn.Sequential(
        nn.Linear(784, 256),
        nn.ReLU(),
        nn.Dropout(0.2),
        nn.Linear(256, 10)
    ).to(device)

    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    # 4. Resume Contract: Extract starting epoch (injected automatically on resume)
    start_epoch = int(globals().get("resume_epoch", os.getenv("COMPUTEAI_RESUME_EPOCH", 0)))
    total_epochs = start_epoch + 20

    if start_epoch > 0:
        print(f"✓ Resuming training run starting from epoch {start_epoch + 1}")
    else:
        print("✓ Starting fresh training run from epoch 1")

    # 5. Training Loop: Begins from start_epoch + 1
    # Note: ComputeAI autowrapper AUTOMATICALLY persists epoch checkpoints to CHECKPOINT_DIR
    print(f"Executing training loop from epoch {start_epoch + 1} to {total_epochs}...")
    for epoch in range(start_epoch + 1, total_epochs + 1):
        model.train()

        # [Insert data loader batch training step here]
        mock_loss = 0.5 / (epoch ** 0.5)
        mock_acc = 0.70 + (0.014 * epoch)

        # Standard stdout log formatting captured by ComputeAI monitoring:
        print(f"Epoch {epoch}/{total_epochs} | Loss: {mock_loss:.4f} | Accuracy: {mock_acc:.4f}")

    # 6. Final Model Export
    final_model_path = os.path.join(output_dir, "model_final.pt")
    torch.save(model.state_dict(), final_model_path)
    print(f"✓ Training complete. Final model saved to: {final_model_path}")

if __name__ == "__main__":
    main()

import os
import tensorflow as tf

def main():
    # 1. Workspace Path Resolution
    workspace = os.getenv("USER_WORKSPACE", "./workspace")
    dataset_dir = os.getenv("DATASET_DIR", os.path.join(workspace, "datasets"))
    output_dir = os.getenv("JOB_OUTPUT_DIR", os.path.join(workspace, "outputs"))
    os.makedirs(output_dir, exist_ok=True)

    # 2. Build Model
    model = tf.keras.Sequential([
        tf.keras.layers.Input(shape=(784,)),
        tf.keras.layers.Dense(256, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(10, activation='softmax')
    ])

    model.compile(
        optimizer='adam',
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy']
    )

    # 3. Resume Contract: Extract starting epoch (injected automatically on resume)
    start_epoch = int(globals().get("resume_epoch", os.getenv("COMPUTEAI_RESUME_EPOCH", 0)))
    total_epochs = start_epoch + 20

    if start_epoch > 0:
        print(f"✓ Resuming training from epoch {start_epoch + 1}")
    else:
        print("✓ Starting fresh training run from epoch 1")

    # 4. Execute Training (initial_epoch handles resume index cleanly)
    # model.fit(dataset, epochs=total_epochs, initial_epoch=start_epoch)
    print(f"✓ Ready to train TensorFlow model from epoch {start_epoch + 1} to {total_epochs}")

if __name__ == "__main__":
    main()

import mlflow

# Track metrics directly during training loop
mlflow.log_metric("train_loss", loss_value, step=current_epoch)
mlflow.log_metric("val_accuracy", val_acc, step=current_epoch)