from tritonml import deploy

# Deploy any HuggingFace model
client = deploy("cardiffnlp/twitter-roberta-base-emotion")

# Make predictions
result = client.predict("I love this framework!")
print(result)  # Output: "joy"

from tritonml import TritonModel

# Load a model from HuggingFace
model = TritonModel.from_huggingface(
    "bert-base-uncased",
    task="text-classification"  # Auto-detected if not specified
)

# Convert and optimize
model.convert()              # Convert to ONNX
model.quantize()            # Apply INT8 quantization
model.optimize()            # Apply graph optimizations

# Deploy
client = model.deploy(server_url="localhost:8000")

# Use the model
result = model.predict("Hello world!")

from tritonml.tasks import TextClassificationModel, EmotionClassifier

# Generic text classification
model = TextClassificationModel.from_pretrained(
    "distilbert-base-uncased-finetuned-sst-2-english",
    labels=["negative", "positive"]
)

# Specialized emotion classifier
emotion_model = EmotionClassifier.from_pretrained()
emotions = emotion_model.predict([
    "I'm furious!",
    "Best day ever!",
    "Things will improve",
    "Feeling down..."
])

from tritonml.core.converter import get_converter

# Get appropriate converter
converter = get_converter("onnx", model, config)

# Convert with options
converter.convert(
    output_path="./models/my-model",
    opset_version=14,
    optimize_for_gpu=True
)

# Quantize for better performance
converter.quantize(
    method="dynamic",  # or "static" with calibration data
    per_channel=True
)

from tritonml import TextClassificationModel, BenchmarkRunner, HuggingFaceDatasetLoader

# Load and deploy your model
model = TextClassificationModel.from_pretrained("distilbert-base-uncased-finetuned-sst-2-english")
model.deploy()

# Create benchmark runner
runner = BenchmarkRunner(model)

# Load a dataset
dataset_loader = HuggingFaceDatasetLoader("imdb", split="test")

# Run benchmark
results = runner.benchmark_dataset(
    dataset_loader,
    batch_sizes=[1, 8, 16, 32],
    num_samples=1000
)

# Print summary
runner.print_summary()

# Save results
runner.save_results("benchmark_results.json")

# Define dataset configurations
datasets = [
    {"dataset_name": "imdb", "split": "test"},
    {"dataset_name": "rotten_tomatoes", "split": "test"},
    {"dataset_name": "emotion", "split": "test"}
]

# Run benchmarks
results = runner.benchmark_multiple_datasets(
    datasets,
    batch_sizes=[1, 8, 16],
    num_samples=500
)

from tritonml.core.model import TritonModel
from tritonml.core.config import TritonConfig

class MyCustomModel(TritonModel):
    @classmethod
    def from_pretrained(cls, model_path, **kwargs):
        # Load your model
        config = TritonConfig(
            model_name="my-model",
            input_shapes={"input": [512]},
            output_shapes={"output": [10]}
        )
        return cls(config)
    
    def preprocess(self, inputs):
        # Custom preprocessing
        return {"input": process_inputs(inputs)}
    
    def postprocess(self, outputs):
        # Custom postprocessing
        return outputs["output"].argmax()

from tritonml.core.config import TritonConfig

config = TritonConfig(
    model_name="my-model",
    max_batch_size=64,
    instance_group={"kind": "KIND_GPU", "count": 2},
    dynamic_batching={
        "preferred_batch_size": [8, 16, 32],
        "max_queue_delay_microseconds": 100
    }
)

model = MyCustomModel(config)

from tritonml.deploy.docker import create_deployment_package

create_deployment_package(
    model_name="emotion-classifier",
    output_path="./deploy",
    include_client=True
)

# Built-in benchmarking
results = model.benchmark(
    test_inputs=["sample text"] * 100,
    batch_sizes=[1, 8, 16, 32, 64]
)

for batch_size, metrics in results.items():
    print(f"{batch_size}: {metrics['avg_latency_ms']:.2f}ms, "
          f"{metrics['throughput']:.2f} samples/sec")