Use Cases

NCN Network v2 enables various decentralized AI applications. This page covers common use cases and implementation patterns.

---

AI Inference as a Service

Overview

Deploy AI models and offer inference as a pay-per-use service.

┌──────────┐     ┌──────────────┐     ┌───────────────┐
│  Client  │────▶│   Gateway    │────▶│ Compute Node  │
│  (App)   │     │  (Your Org)  │     │  (GPU Farm)   │
└──────────┘     └──────────────┘     └───────────────┘
      │                                       │
      └───────────── Payment ─────────────────┘

Benefits

• No infrastructure management: Use existing compute providers

• Pay only for usage: No idle GPU costs

• Scalable: Add more compute nodes as demand grows

• Transparent pricing: On-chain payment records

Implementation

1. Gateway Operator: Create a subnet with your models

2. Compute Providers: Join your subnet, provide GPU resources

3. Clients: Send inference requests, pay per request

Example: Image Classification Service

# Client code
import requests

response = requests.post(
    "https://your-gateway.com/api/v1/inference",
    json={
        "model_uuid": "resnet50",
        "input_data": {"image_url": "https://example.com/image.jpg"}
    },
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)

result = response.json()
print(f"Classification: {result['output_data']}")

---

Decentralized Model Hosting

Overview

Host AI models in a decentralized network where multiple compute providers can serve requests.

Architecture

                    ┌────────────────┐
                    │    Subnet      │
                    │  (Model Set)   │
                    └───────┬────────┘
                            │
        ┌───────────────────┼───────────────────┐
        │                   │                   │
┌───────▼───────┐   ┌───────▼───────┐   ┌───────▼───────┐
│  Compute 1    │   │  Compute 2    │   │  Compute 3    │
│  (Provider A) │   │  (Provider B) │   │  (Provider C) │
└───────────────┘   └───────────────┘   └───────────────┘

Benefits

• Redundancy: Multiple providers serve requests

• Geographic distribution: Low latency worldwide

• Censorship resistance: No single point of control

• Competition: Providers compete on price and quality

Setup

1. Create Subnet:

   subnet-cli create -c model_config.json

2. Providers Join:

   compute_node --subnet-id 1 --sync-models

3. Clients Connect:

   # Requests automatically routed to available providers

---

Text-to-Audio Pipeline (Bark)

Overview

NCN Network supports the Bark text-to-audio model with distributed pipeline execution.

Pipeline Stages

Input Text → Semantic → Coarse → Fine → Audio Output
              Stage      Stage    Stage

Implementation

The Bark pipeline uses three specialized models:

Stage	Model	Purpose
Semantic	bark_semantic_model.pt	Text to semantic tokens
Coarse	bark_coarse_model.pt	Semantic to coarse acoustic tokens
Fine	bark_fine_model.pt	Coarse to fine acoustic tokens

Subnet Configuration

{
  "gateway_address": "0xYourGateway",
  "models": [
    {
      "name": "bark_semantic",
      "download_url": "https://huggingface.co/suno/bark/resolve/main/...",
      "executor_script": "semantic_model_executor.py"
    },
    {
      "name": "bark_coarse",
      "download_url": "https://huggingface.co/suno/bark/resolve/main/...",
      "executor_script": "coarse_model_executor.py"
    },
    {
      "name": "bark_fine",
      "download_url": "https://huggingface.co/suno/bark/resolve/main/...",
      "executor_script": "fine_model_executor.py"
    }
  ]
}

Client Usage

# Run Bark pipeline
text = "Hello, this is a test of the NCN Network text-to-speech system."

# Stage 1: Semantic
semantic_tokens = client.inference("bark_semantic", {"text": text})

# Stage 2: Coarse
coarse_tokens = client.inference("bark_coarse", {"semantic_tokens": semantic_tokens})

# Stage 3: Fine
audio_data = client.inference("bark_fine", {"coarse_tokens": coarse_tokens})

# Save audio
with open("output.wav", "wb") as f:
    f.write(audio_data)

---

Custom Model Deployment

Overview

Deploy your own trained models on the NCN Network.

Requirements

1. Model Format: TorchScript (.pt), ONNX (.onnx), or Safetensors

2. Executor Script: Python script for inference

3. Input/Output Schema: JSON format definition

Step-by-Step

1. Export Your Model

import torch

# Your trained model
model = MyModel()
model.load_state_dict(torch.load("model_weights.pth"))
model.eval()

# Export to TorchScript
scripted = torch.jit.script(model)
scripted.save("my_model.pt")

2. Create Executor Script

# my_model_executor.py
import os
import json
import torch

def main():
    # Load input
    input_file = os.environ.get("INPUT_FILE")
    with open(input_file) as f:
        input_data = json.load(f)
    
    # Load model
    model = torch.jit.load("my_model.pt")
    
    # Run inference
    input_tensor = torch.tensor(input_data["input"])
    output = model(input_tensor)
    
    # Write output
    output_file = os.environ.get("OUTPUT_FILE")
    with open(output_file, "w") as f:
        json.dump({"output": output.tolist()}, f)

if __name__ == "__main__":
    main()

3. Configure Subnet

{
  "models": [
    {
      "name": "my_model",
      "download_url": "https://your-storage.com/my_model.pt",
      "executor_script": "base64_encoded_executor_script",
      "file_size_bytes": 500000000
    }
  ]
}

4. Deploy

subnet-cli create -c my_model_config.json

---

Batch Processing

Overview

Process large batches of inference requests efficiently.

Architecture

┌─────────────────────────────────────────────────────────┐
│                    Batch Job                             │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │ Request │  │ Request │  │ Request │  │ Request │ ...│
│  │    1    │  │    2    │  │    3    │  │    N    │    │
│  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘    │
└───────┼────────────┼────────────┼────────────┼──────────┘
        │            │            │            │
        ▼            ▼            ▼            ▼
    ┌───────────────────────────────────────────────┐
    │              Load Balancer                     │
    │         (Gateway Distribution)                 │
    └───────────────────────────────────────────────┘
        │            │            │            │
        ▼            ▼            ▼            ▼
    ┌────────┐  ┌────────┐  ┌────────┐  ┌────────┐
    │Compute1│  │Compute2│  │Compute3│  │Compute4│
    └────────┘  └────────┘  └────────┘  └────────┘

Implementation

import asyncio
from ncn_client import NCNClient

async def process_batch(items):
    client = NCNClient("https://gateway.example.com")
    
    # Submit all requests concurrently
    tasks = [
        client.inference_async("model_name", item)
        for item in items
    ]
    
    # Wait for all results
    results = await asyncio.gather(*tasks)
    return results

# Process 1000 items
batch = load_batch_data()
results = asyncio.run(process_batch(batch))

---

Real-Time Applications

Overview

Build real-time AI applications with WebSocket streaming.

WebSocket Connection

const ws = new WebSocket("wss://gateway.example.com/ws");

ws.onopen = () => {
    // Subscribe to task updates
    ws.send(JSON.stringify({
        type: "subscribe",
        request_id: "my-request-123"
    }));
};

ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    
    if (data.type === "task_status") {
        console.log(`Status: ${data.status}`);
    } else if (data.type === "task_result") {
        console.log(`Result: ${data.output_data}`);
    }
};

Use Cases

• Live transcription

• Real-time translation

• Interactive chatbots

• Voice assistants

---

Next Steps

• Getting Started - Set up your environment

• Key Concepts - Understand the system

• Client Integration - Build your client