L

Initializing Studio...

Documentation

Getting Started

  • Introduction
  • Quick Start
  • Installation

Fine-tuning

  • LoRA & QLoRA
  • Full Fine-tuning

API & SDK

  • REST API
  • Python SDK

Deployment

  • Cloud Deployment
  • Security

Resources

  • FAQ
  • Changelog

Models

Understand model types, architectures, and lifecycle management in LangTrain.

Model Types

LangTrain supports various model types optimized for different use cases:

Text Classification:
•Categorize text into predefined classes

•Use cases: Sentiment analysis, spam detection, topic classification

•Metrics: Accuracy, precision, recall, F1-score


Language Generation:
•Generate human-like text responses

•Use cases: Chatbots, content creation, code generation

•Metrics: BLEU, ROUGE, perplexity


Named Entity Recognition (NER):
•Identify and classify entities in text

•Use cases: Information extraction, document processing

•Metrics: Entity-level F1, precision, recall


Text Embeddings:
•Convert text into dense vector representations

•Use cases: Semantic search, clustering, recommendations

•Metrics: Cosine similarity, downstream task performance


Custom Models:
•Upload your own PyTorch or TensorFlow models

•Full control over architecture and training

•Integration with LangTrain's deployment infrastructure

Pre-trained Models

LangTrain provides access to state-of-the-art pre-trained models:

Language Models:
•BERT: Bidirectional encoder for understanding tasks

•GPT: Generative models for text completion

•T5: Text-to-text transfer transformer

•RoBERTa: Optimized BERT variant

•DistilBERT: Lightweight, fast BERT variant


Specialized Models:
•Domain-specific models (legal, medical, financial)

•Multilingual models supporting 100+ languages

•Code-understanding models for programming tasks


Fine-tuning Benefits:
•Start with proven architectures

•Reduced training time and data requirements

•Better performance on most tasks

•Cost-effective model development

Model Architecture

Understanding model architectures helps optimize performance:

Transformer Architecture:
•Self-attention mechanism for understanding context

•Encoder-decoder or encoder-only designs

•Positional encoding for sequence understanding

•Multi-head attention for different representation aspects


Model Size Considerations:
•Small Models (< 100M params): Fast inference, mobile deployment

•Medium Models (100M-1B params): Balanced performance/efficiency

•Large Models (> 1B params): State-of-the-art performance


Hardware Requirements:
•GPU memory scales with model size

•Batch size affects training speed

•Gradient accumulation for limited memory

•Mixed precision training for efficiency

Model Lifecycle

Manage models through their complete lifecycle:

1. Creation Phase:
•Define model type and configuration

•Set up training parameters

•Prepare training data


2. Training Phase:
•Monitor training progress

•Track metrics and loss curves

•Handle training failures and restarts


3. Evaluation Phase:
•Validate on held-out data

•Compare with baseline models

•Analyze error cases and biases


4. Deployment Phase:
•Deploy to staging environment

•Performance testing and optimization

•Production deployment with monitoring


5. Maintenance Phase:
•Monitor model drift and performance

•Retrain with new data

•Version control and rollback capabilities

Model Versioning

Track and manage different versions of your models:

Version Control:
•Automatic versioning for each training run

•Semantic versioning (major.minor.patch)

•Tag versions with descriptive names

•Compare performance across versions


Model Registry:
•Centralized storage for all models

•Metadata tracking (datasets, hyperparameters, metrics)

•Access control and permissions

•Integration with CI/CD pipelines


Rollback Capabilities:
•Instant rollback to previous versions

•A/B testing between versions

•Gradual rollout of new versions

•Automated fallback on performance degradation

Model Optimization

Optimize models for better performance and efficiency:

Performance Optimization:
•Quantization to reduce model size

•Pruning to remove unnecessary parameters

•Knowledge distillation from larger models

•Optimized inference engines (ONNX, TensorRT)


Cost Optimization:
•Right-sizing compute resources

•Batch prediction for efficiency

•Caching for repeated queries

•Spot instances for training


Latency Optimization:
•Model compression techniques

•Edge deployment options

•Speculative decoding for generation

•Pipeline parallelism for large models

Full Examples

Create Different Model Types

python
1import langtrain
2

3client = langtrain.LangTrain()
4

5# Text classification model
6classifier = client.models.create(
7    name="product-categorizer",
8    type="text-classification",
9    labels=["electronics", "clothing", "books", "home"],
10    base_model="bert-base-uncased"
11)
12

13# Text generation model
14generator = client.models.create(
15    name="content-writer",
16    type="text-generation",
17    base_model="gpt-3.5-turbo",
18    max_length=512
19)
20

21# NER model
22ner_model = client.models.create(
23    name="document-extractor",
24    type="named-entity-recognition",
25    entity_types=["PERSON", "ORG", "DATE", "MONEY"]
26)

Model Management

python
1# List all models
2models = client.models.list()
3for model in models:
4    print(f"Model: {model.name} (v{model.version})")
5    print(f"Type: {model.type}")
6    print(f"Status: {model.status}")
7    print("---")
8

9# Get specific model
10model = client.models.get("product-categorizer")
11

12# Update model metadata
13model.update(
14    description="Updated product categorization model",
15    tags=["production", "v2.0"]
16)
17

18# Clone model for experimentation
19cloned_model = model.clone(
20    name="product-categorizer-experiment",
21    description="Experimental version with new architecture"
22)

Model Comparison

python
1# Compare model versions
2comparison = client.models.compare(
3    model_ids=["model-v1", "model-v2", "model-v3"],
4    metrics=["accuracy", "f1_score", "latency"]
5)
6

7print("Model Comparison:")
8for model_id, metrics in comparison.items():
9    print(f"{model_id}:")
10    for metric, value in metrics.items():
11        print(f"  {metric}: {value}")
12

13# Get best performing model
14best_model = comparison.get_best(metric="f1_score")
15print(f"Best model: {best_model.id}")
16

17# Deploy best model
18deployment = best_model.deploy(
19    name="production-classifier",
20    auto_scale=True
21)

Custom Model Upload

python
1# Upload custom PyTorch model
2import torch
3

4# Your custom model class
5class CustomClassifier(torch.nn.Module):
6    def __init__(self, vocab_size, embed_dim, num_classes):
7        super().__init__()
8        self.embedding = torch.nn.Embedding(vocab_size, embed_dim)
9        self.classifier = torch.nn.Linear(embed_dim, num_classes)
10    
11    def forward(self, x):
12        embedded = self.embedding(x).mean(dim=1)
13        return self.classifier(embedded)
14

15# Upload to LangTrain
16model = client.models.upload_custom(
17    name="my-custom-model",
18    model_class=CustomClassifier,
19    model_path="./my_model.pth",
20    tokenizer_path="./tokenizer.json",
21    config={
22        "vocab_size": 10000,
23        "embed_dim": 128,
24        "num_classes": 5
25    }
26)

On this page

Model TypesPre-trained ModelsModel ArchitectureModel LifecycleModel VersioningModel Optimization