AI/ML Platform

Hugging Face

Overview

Hugging Face is an open-source library and platform for machine learning and NLP (Natural Language Processing). With a comprehensive ecosystem centered around the Transformers library, it provides an environment where state-of-the-art models like BERT, GPT, and T5 can be easily utilized with PyTorch, TensorFlow, and JAX. As a rapidly growing platform in the AI/ML field, it operates the Hugging Face Hub providing over 1 million pre-trained models and is supported by a wide community from researchers to enterprises. It's an innovative open-source platform promoting the democratization of text, image, audio, and multimodal AI.

Details

Hugging Face 2025 has established open-source leadership in the AI/ML field and is widely adopted from academic research to commercial applications. It integrates diverse libraries including Transformers, Datasets, Diffusers, and Accelerate, building an ecosystem centered on the Hugging Face Hub that provides over 1 million models, 200,000+ datasets, and 400,000+ demos. While being completely open-source under Apache 2.0 license, it also offers commercial services like Enterprise Hub, Inference API, and AutoTrain, continuing to grow as a comprehensive platform supporting the entire AI development process.

Key Features

• Transformers Library: Industry-standard Transformer model library with 6,000+ code snippets
• Hugging Face Hub: 1M+ models, 200K+ datasets, Git-based collaboration
• Multi-framework Support: Seamless support for PyTorch, TensorFlow, JAX, ONNX, ggml
• Real-time Inference: High-speed inference with Inference API and Text Embeddings Inference
• Dataset Management: Efficient data processing and streaming with Datasets library
• Open Source: Completely open-source under Apache 2.0 license

Advantages and Disadvantages

Advantages

• Completely open-source and free to use with no commercial restrictions
• Rich selection and immediate utilization with 1M+ pre-trained models
• Multi-framework support for PyTorch, TensorFlow, and JAX
• Community-driven continuous improvement and rapid integration of latest technologies
• Excellent reproducibility and version control with Git-based workflow
• Flexible usage from lightweight Pipeline API to Advanced API

Disadvantages

• Learning cost and need to master best practices due to rich functionality
• Heavy GPU memory and compute resource consumption for large model inference
• Constraints from commercial Inference API pricing and rate limits
• Frequent API changes and version compatibility issues due to rapid development
• Risk of model quality and licensing depending on community contributions
• Limited enterprise support and SLA

Reference Links

• Hugging Face Official Site
• Transformers Documentation
• Datasets Documentation
• Hugging Face Hub Documentation
• Hugging Face GitHub
• Hugging Face Cookbook

Code Examples

Basic Setup and Model Loading

# Install Hugging Face Transformers
pip install transformers torch

# Install essential libraries
pip install datasets accelerate bitsandbytes

# Basic setup in Python environment
from transformers import (
    AutoTokenizer, AutoModel, AutoModelForCausalLM,
    pipeline, BitsAndBytesConfig
)
import torch

# Device configuration
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using device: {device}")

# Basic model loading
model_name = "microsoft/DialoGPT-large"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

print("Model loaded successfully")

# Check available tasks
from transformers import SUPPORTED_TASKS
print("Supported tasks:")
for task in list(SUPPORTED_TASKS.keys())[:10]:
    print(f"- {task}")

# Get model information
print(f"\nModel name: {model.config.name_or_path}")
print(f"Model type: {model.config.model_type}")
print(f"Vocabulary size: {model.config.vocab_size}")

# Memory mapping example
from datasets import load_dataset
import os
import psutil

# Check memory usage before loading
mem_before = psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024)
dataset = load_dataset("squad", split="train[:1000]")
mem_after = psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024)

print(f"\nRAM memory used for dataset: {(mem_after - mem_before):.1f} MB")
print(f"Dataset size: {len(dataset)} examples")

Text Generation and Language Models

from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
import torch

# Text generation pipeline
text_generator = pipeline(
    "text-generation",
    model="gpt2",
    torch_dtype=torch.float16,
    device_map="auto"
)

# Basic text generation
prompt = "The future of artificial intelligence is"
generated = text_generator(
    prompt,
    max_length=200,
    num_return_sequences=1,
    temperature=0.7,
    do_sample=True,
    pad_token_id=text_generator.tokenizer.eos_token_id
)

print("=== Generated Text ===")
print(generated[0]['generated_text'])

# Multiple generation results comparison
multiple_results = text_generator(
    "Programming tips for beginners:",
    max_length=150,
    num_return_sequences=3,
    temperature=0.8,
    do_sample=True
)

print("\n=== Multiple Generation Results ===")
for i, result in enumerate(multiple_results):
    print(f"Result {i+1}: {result['generated_text']}")
    print("-" * 50)

# Conditional text generation (ChatGPT style)
from transformers import AutoTokenizer, AutoModelForCausalLM

model_name = "microsoft/DialoGPT-large"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Chat history management
chat_history_ids = None

def chat_with_model(user_input, chat_history_ids):
    # Encode user input
    new_user_input_ids = tokenizer.encode(
        user_input + tokenizer.eos_token, 
        return_tensors='pt'
    )
    
    # Concatenate with conversation history
    if chat_history_ids is not None:
        bot_input_ids = torch.cat([chat_history_ids, new_user_input_ids], dim=-1)
    else:
        bot_input_ids = new_user_input_ids
    
    # Generate response
    chat_history_ids = model.generate(
        bot_input_ids,
        max_length=1000,
        num_beams=5,
        early_stopping=True,
        pad_token_id=tokenizer.eos_token_id
    )
    
    # Decode response
    response = tokenizer.decode(
        chat_history_ids[:, bot_input_ids.shape[-1]:][0], 
        skip_special_tokens=True
    )
    
    return response, chat_history_ids

# Conversation example
print("\n=== Interactive Text Generation ===")
user_inputs = [
    "Hello, how are you?",
    "What's your favorite programming language?",
    "Can you help me learn Python?"
]

for user_input in user_inputs:
    response, chat_history_ids = chat_with_model(user_input, chat_history_ids)
    print(f"User: {user_input}")
    print(f"Bot: {response}")
    print("-" * 40)

# Streaming generation
print("\n=== Streaming Generation ===")
from transformers import TextIteratorStreamer
import threading

model_name = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)

prompt = "The key to successful programming is"
inputs = tokenizer(prompt, return_tensors="pt")

# Generate in separate thread
generation_kwargs = dict(
    inputs, 
    streamer=streamer, 
    max_new_tokens=100,
    temperature=0.7,
    do_sample=True
)

thread = threading.Thread(target=model.generate, kwargs=generation_kwargs)
thread.start()

print(f"Prompt: {prompt}")
print("Streaming response: ", end="")
for new_text in streamer:
    print(new_text, end="", flush=True)
print()  # New line

Natural Language Processing Tasks

from transformers import pipeline
import torch

# Sentiment analysis
sentiment_analyzer = pipeline(
    "sentiment-analysis",
    model="cardiffnlp/twitter-xlm-roberta-base-sentiment"
)

texts = [
    "This is an amazing product!",
    "This product is terrible...",
    "It's okay, nothing special."
]

print("=== Sentiment Analysis ===")
for text in texts:
    result = sentiment_analyzer(text)
    print(f"Text: {text}")
    print(f"Sentiment: {result[0]['label']}, Score: {result[0]['score']:.3f}")
    print()

# Named Entity Recognition (NER)
ner_pipeline = pipeline(
    "ner",
    model="dbmdz/bert-large-cased-finetuned-conll03-english",
    aggregation_strategy="simple"
)

text = "Apple Inc. was founded by Steve Jobs in Cupertino, California."
ner_results = ner_pipeline(text)

print("=== Named Entity Recognition ===")
print(f"Text: {text}")
print("Detected entities:")
for entity in ner_results:
    print(f"- {entity['word']}: {entity['entity_group']} (score: {entity['score']:.3f})")

# Text summarization
summarizer = pipeline(
    "summarization",
    model="facebook/bart-large-cnn"
)

long_text = """
Artificial Intelligence (AI) has revolutionized numerous industries and aspects of daily life. 
From healthcare diagnostics to autonomous vehicles, AI technologies are transforming how we work, 
communicate, and solve complex problems. Machine learning, a subset of AI, enables computers to 
learn and improve from experience without being explicitly programmed. Deep learning, which uses 
neural networks with multiple layers, has been particularly successful in areas like image 
recognition, natural language processing, and speech recognition. However, the rapid advancement 
of AI also raises important ethical considerations, including concerns about job displacement, 
privacy, bias in algorithmic decision-making, and the need for transparent and accountable AI systems.
"""

summary = summarizer(long_text, max_length=100, min_length=30, do_sample=False)

print("\n=== Text Summarization ===")
print("Original text:")
print(long_text)
print(f"\nSummary: {summary[0]['summary_text']}")

# Question Answering
qa_pipeline = pipeline(
    "question-answering",
    model="distilbert-base-cased-distilled-squad"
)

context = """
The Transformer architecture was introduced in the paper "Attention Is All You Need" by Vaswani et al. in 2017. 
It relies entirely on attention mechanisms to draw global dependencies between input and output. 
The Transformer allows for significantly more parallelization and can reach a new state of the art 
in translation quality after being trained for as little as twelve hours on eight P100 GPUs.
"""

questions = [
    "Who introduced the Transformer architecture?",
    "When was the Transformer introduced?",
    "What does the Transformer rely on?"
]

print("\n=== Question Answering ===")
print(f"Context: {context}")
print()

for question in questions:
    result = qa_pipeline(question=question, context=context)
    print(f"Question: {question}")
    print(f"Answer: {result['answer']} (score: {result['score']:.3f})")
    print()

# Language detection
language_detector = pipeline(
    "text-classification",
    model="papluca/xlm-roberta-base-language-detection"
)

multilingual_texts = [
    "Hello, how are you today?",
    "Bonjour, comment allez-vous?",
    "Hola, ¿cómo estás?",
    "こんにちは、元気ですか？"
]

print("=== Language Detection ===")
for text in multilingual_texts:
    result = language_detector(text)
    print(f"Text: {text}")
    print(f"Language: {result[0]['label']} (confidence: {result[0]['score']:.3f})")
    print()

Computer Vision and Multimodal Models

from transformers import pipeline, AutoProcessor, AutoModelForImageTextToText
import torch
from PIL import Image
import requests

# Image classification
image_classifier = pipeline(
    "image-classification",
    model="google/vit-base-patch16-224"
)

# Load sample image
image_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/PNG_transparency_demonstration_1.png/280px-PNG_transparency_demonstration_1.png"
image = Image.open(requests.get(image_url, stream=True).raw)

print("=== Image Classification ===")
results = image_classifier(image)
for result in results[:5]:
    print(f"Class: {result['label']}, Score: {result['score']:.3f}")

# Object detection
object_detector = pipeline(
    "object-detection",
    model="facebook/detr-resnet-50"
)

detection_results = object_detector(image)

print("\n=== Object Detection ===")
for detection in detection_results:
    print(f"Object: {detection['label']}")
    print(f"Score: {detection['score']:.3f}")
    print(f"Coordinates: {detection['box']}")
    print()

# Image captioning
captioner = pipeline(
    "image-to-text",
    model="Salesforce/blip-image-captioning-base"
)

captions = captioner(image)
print("=== Image Captioning ===")
for caption in captions:
    print(f"Caption: {caption['generated_text']}")

# Visual Question Answering (VQA)
vqa_pipeline = pipeline(
    "visual-question-answering",
    model="dandelin/vilt-b32-finetuned-vqa"
)

questions = [
    "What is in this image?",
    "What colors are visible?",
    "Is this a photograph or a drawing?"
]

print("\n=== Visual Question Answering ===")
for question in questions:
    result = vqa_pipeline(image, question)
    print(f"Question: {question}")
    print(f"Answer: {result['answer']} (score: {result['score']:.3f})")
    print()

# Image segmentation
segmenter = pipeline(
    "image-segmentation",
    model="facebook/detr-resnet-50-panoptic"
)

segmentation_results = segmenter(image)

print("=== Image Segmentation ===")
for result in segmentation_results:
    print(f"Label: {result['label']}")
    print(f"Score: {result['score']:.3f}")
    print(f"Mask size: {result['mask'].size}")
    print()

# Advanced multimodal model (LLaVA example)
print("\n=== Advanced Multimodal Model ===")
try:
    # Load LLaVA model
    processor = AutoProcessor.from_pretrained("llava-hf/llava-1.5-7b-hf")
    model = AutoModelForImageTextToText.from_pretrained(
        "llava-hf/llava-1.5-7b-hf",
        torch_dtype=torch.float16,
        device_map="auto"
    )
    
    # Detailed image analysis
    prompt = "Describe this image in detail. What can you see?"
    inputs = processor(text=prompt, images=image, return_tensors="pt")
    
    # Type conversion for GPU usage
    if torch.cuda.is_available():
        inputs = {k: v.to("cuda") for k, v in inputs.items()}
    
    # Generation
    with torch.no_grad():
        generated_ids = model.generate(
            **inputs,
            max_new_tokens=200,
            do_sample=True,
            temperature=0.7
        )
    
    generated_text = processor.batch_decode(
        generated_ids, 
        skip_special_tokens=True
    )[0]
    
    print(f"Detailed analysis: {generated_text}")
    
except Exception as e:
    print(f"Error in advanced multimodal model example: {e}")
    print("This model requires significant GPU memory")

# Zero-shot image classification
zero_shot_classifier = pipeline(
    "zero-shot-image-classification",
    model="openai/clip-vit-base-patch32"
)

candidate_labels = ["a cat", "a dog", "a car", "a house", "nature scene"]
zero_shot_results = zero_shot_classifier(image, candidate_labels)

print("\n=== Zero-shot Image Classification ===")
for result in zero_shot_results:
    print(f"Label: {result['label']}, Score: {result['score']:.3f}")

Model Training and Fine-tuning

from transformers import (
    AutoTokenizer, AutoModelForSequenceClassification,
    TrainingArguments, Trainer, DataCollatorWithPadding
)
from datasets import Dataset, load_dataset
import torch
import numpy as np
from sklearn.metrics import accuracy_score, precision_recall_fscore_support

# Dataset preparation
print("=== Dataset Preparation ===")

# Create sample data (use large-scale datasets in practice)
sample_data = {
    'text': [
        "This service is amazing!",
        "Worst experience ever",
        "Average quality I think",
        "Very satisfied with this",
        "Needs improvement",
        "Exceeded my expectations"
    ],
    'label': [1, 0, 0, 1, 0, 1]  # 1: Positive, 0: Negative
}

# Convert to Hugging Face Dataset
dataset = Dataset.from_dict(sample_data)
print(f"Dataset size: {len(dataset)}")

# Train-test split
train_test_split = dataset.train_test_split(test_size=0.2)
train_dataset = train_test_split['train']
eval_dataset = train_test_split['test']

# Load model and tokenizer
model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
    model_name,
    num_labels=2
)

# Data preprocessing
def preprocess_function(examples):
    return tokenizer(
        examples['text'],
        truncation=True,
        padding=True,
        max_length=128
    )

# Tokenize datasets
train_dataset = train_dataset.map(preprocess_function, batched=True)
eval_dataset = eval_dataset.map(preprocess_function, batched=True)

# Data collator configuration
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

# Define evaluation function
def compute_metrics(eval_pred):
    predictions, labels = eval_pred
    predictions = np.argmax(predictions, axis=1)
    
    accuracy = accuracy_score(labels, predictions)
    precision, recall, f1, _ = precision_recall_fscore_support(
        labels, predictions, average='weighted'
    )
    
    return {
        'accuracy': accuracy,
        'f1': f1,
        'precision': precision,
        'recall': recall
    }

# Training arguments configuration
training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=2,
    per_device_eval_batch_size=2,
    warmup_steps=100,
    weight_decay=0.01,
    logging_dir='./logs',
    logging_steps=10,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    metric_for_best_model="f1"
)

# Initialize Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    data_collator=data_collator,
    compute_metrics=compute_metrics,
)

print("\n=== Model Training Start ===")
# Execute training (takes time in actual environment)
# trainer.train()

print("Training setup completed (actual training commented out)")

# Example of saving trained model
# model.save_pretrained("./fine-tuned-model")
# tokenizer.save_pretrained("./fine-tuned-model")

# Inference example
print("\n=== Post Fine-tuning Inference Example ===")
test_texts = [
    "I love this app, it's so easy to use",
    "Too many bugs, completely unusable"
]

# Simple inference pipeline
classifier = pipeline(
    "text-classification",
    model=model,
    tokenizer=tokenizer
)

for text in test_texts:
    result = classifier(text)
    print(f"Text: {text}")
    print(f"Prediction: {result[0]['label']}, Score: {result[0]['score']:.3f}")
    print()

# Model quantization for lightweight deployment
print("=== Model Quantization Example ===")
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True
)

# Example of loading quantized model
# quantized_model = AutoModelForCausalLM.from_pretrained(
#     "microsoft/DialoGPT-large",
#     quantization_config=quantization_config,
#     device_map="auto"
# )

print("Quantization configuration completed (effective for large models)")

# Custom training loop example
print("\n=== Custom Training Loop Example ===")
from torch.utils.data import DataLoader
from torch.optim import AdamW
from tqdm import tqdm

# Setup for custom training
custom_model = AutoModelForSequenceClassification.from_pretrained(
    "bert-base-uncased", 
    num_labels=2
)
optimizer = AdamW(custom_model.parameters(), lr=2e-5)

# Create DataLoader
train_dataloader = DataLoader(
    train_dataset.remove_columns(['text']),
    batch_size=2,
    shuffle=True,
    collate_fn=data_collator
)

# Custom training function
def custom_train_step(model, batch, optimizer):
    model.train()
    optimizer.zero_grad()
    
    outputs = model(**batch)
    loss = outputs.loss
    loss.backward()
    optimizer.step()
    
    return loss.item()

# Training loop example (commented out for demo)
print("Custom training loop configured")
# num_epochs = 2
# for epoch in range(num_epochs):
#     total_loss = 0
#     for batch in tqdm(train_dataloader, desc=f"Epoch {epoch+1}"):
#         loss = custom_train_step(custom_model, batch, optimizer)
#         total_loss += loss
#     
#     avg_loss = total_loss / len(train_dataloader)
#     print(f"Epoch {epoch+1}, Average Loss: {avg_loss:.4f}")

print("Training setup completed")

Deployment and Production Integration

from transformers import pipeline, AutoTokenizer, AutoModel
import torch
import time
import logging
from typing import List, Dict, Optional
import json

# Logging configuration
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class HuggingFaceModelService:
    """Production-ready Hugging Face model service class"""
    
    def __init__(self, model_name: str, task: str, device: str = "auto"):
        self.model_name = model_name
        self.task = task
        self.device = device
        self.pipeline = None
        self.load_model()
    
    def load_model(self):
        """Load model"""
        try:
            logger.info(f"Starting model loading: {self.model_name}")
            self.pipeline = pipeline(
                self.task,
                model=self.model_name,
                device_map=self.device,
                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
            )
            logger.info("Model loading completed")
        except Exception as e:
            logger.error(f"Model loading error: {e}")
            raise
    
    def predict(self, inputs: List[str], **kwargs) -> List[Dict]:
        """Execute prediction"""
        try:
            start_time = time.time()
            results = self.pipeline(inputs, **kwargs)
            end_time = time.time()
            
            logger.info(f"Prediction completed: {len(inputs)} items, processing time: {end_time - start_time:.2f}s")
            return results
        except Exception as e:
            logger.error(f"Prediction error: {e}")
            raise
    
    def batch_predict(self, inputs: List[str], batch_size: int = 8) -> List[Dict]:
        """Batch prediction"""
        results = []
        for i in range(0, len(inputs), batch_size):
            batch = inputs[i:i + batch_size]
            batch_results = self.predict(batch)
            results.extend(batch_results)
        return results
    
    def health_check(self) -> bool:
        """Health check"""
        try:
            test_input = ["Test input"]
            self.predict(test_input)
            return True
        except:
            return False

# Service class usage example
print("=== Production Model Service ===")

# Sentiment analysis service
sentiment_service = HuggingFaceModelService(
    model_name="cardiffnlp/twitter-xlm-roberta-base-sentiment",
    task="sentiment-analysis"
)

# Batch prediction test
test_texts = [
    "Amazing product!",
    "Disappointing...",
    "Average quality",
    "Best service ever!"
]

results = sentiment_service.batch_predict(test_texts)
print("Sentiment analysis results:")
for text, result in zip(test_texts, results):
    print(f"  {text} -> {result['label']} ({result['score']:.3f})")

# API-style interface
class HuggingFaceAPI:
    """API-style interface"""
    
    def __init__(self):
        self.services = {
            'sentiment': HuggingFaceModelService(
                "cardiffnlp/twitter-xlm-roberta-base-sentiment",
                "sentiment-analysis"
            ),
            'summarization': HuggingFaceModelService(
                "facebook/bart-large-cnn",
                "summarization"
            )
        }
    
    def analyze_sentiment(self, texts: List[str]) -> Dict:
        """Sentiment analysis API"""
        try:
            results = self.services['sentiment'].batch_predict(texts)
            return {
                "status": "success",
                "data": results,
                "count": len(results)
            }
        except Exception as e:
            return {
                "status": "error",
                "message": str(e)
            }
    
    def summarize_text(self, texts: List[str], max_length: int = 100) -> Dict:
        """Text summarization API"""
        try:
            results = self.services['summarization'].batch_predict(
                texts, 
                max_length=max_length,
                min_length=30,
                do_sample=False
            )
            return {
                "status": "success",
                "data": results,
                "count": len(results)
            }
        except Exception as e:
            return {
                "status": "error",
                "message": str(e)
            }
    
    def health_check(self) -> Dict:
        """Health check API"""
        status = {}
        for name, service in self.services.items():
            status[name] = service.health_check()
        
        return {
            "status": "healthy" if all(status.values()) else "unhealthy",
            "services": status
        }

# API usage example
print("\n=== API-style Interface ===")
api = HuggingFaceAPI()

# Health check
health = api.health_check()
print(f"Health check: {json.dumps(health, indent=2)}")

# Sentiment analysis API
sentiment_result = api.analyze_sentiment([
    "This new feature is really helpful",
    "Having trouble with many bugs"
])
print(f"\nSentiment analysis result: {json.dumps(sentiment_result, indent=2)}")

# Docker configuration example
docker_config = """
# Dockerfile example
FROM python:3.9-slim

# Install required libraries
RUN pip install transformers torch datasets accelerate

# Copy application code
COPY . /app
WORKDIR /app

# Start service
CMD ["python", "model_service.py"]
"""

print(f"\n=== Docker Configuration Example ===")
print(docker_config)

# Environment variable configuration example
env_config = """
# .env file example
HF_HOME=/app/models
TRANSFORMERS_CACHE=/app/cache
HF_DATASETS_CACHE=/app/datasets_cache
CUDA_VISIBLE_DEVICES=0
MODEL_NAME=cardiffnlp/twitter-xlm-roberta-base-sentiment
BATCH_SIZE=16
MAX_LENGTH=512
"""

print("=== Environment Variable Configuration Example ===")
print(env_config)

# Performance monitoring
def monitor_performance():
    """Performance monitoring"""
    import psutil
    import torch
    
    # CPU usage
    cpu_percent = psutil.cpu_percent(interval=1)
    
    # Memory usage
    memory = psutil.virtual_memory()
    memory_percent = memory.percent
    
    # GPU usage (when CUDA available)
    gpu_info = {}
    if torch.cuda.is_available():
        gpu_info = {
            "gpu_count": torch.cuda.device_count(),
            "current_device": torch.cuda.current_device(),
            "memory_allocated": torch.cuda.memory_allocated() / 1024**2,  # MB
            "memory_reserved": torch.cuda.memory_reserved() / 1024**2   # MB
        }
    
    return {
        "cpu_percent": cpu_percent,
        "memory_percent": memory_percent,
        "gpu_info": gpu_info
    }

# Execute performance monitoring
perf_stats = monitor_performance()
print(f"\n=== Performance Statistics ===")
print(json.dumps(perf_stats, indent=2))

# Production deployment checklist
deployment_checklist = """
=== Production Deployment Checklist ===

1. Model Selection & Optimization:
   - Choose appropriate model size for your hardware
   - Consider quantization for memory efficiency
   - Test inference speed requirements

2. Infrastructure Setup:
   - GPU memory requirements assessment
   - Load balancing configuration
   - Auto-scaling policies

3. Monitoring & Logging:
   - Request/response logging
   - Performance metrics tracking
   - Error monitoring and alerting

4. Security Considerations:
   - Input validation and sanitization
   - Rate limiting implementation
   - Authentication and authorization

5. Model Management:
   - Version control for models
   - A/B testing capabilities
   - Rollback procedures

6. Data Pipeline:
   - Input preprocessing standardization
   - Output formatting consistency
   - Error handling for edge cases
"""

print(deployment_checklist)

# Advanced caching example
class ModelCache:
    """Model result caching"""
    
    def __init__(self, max_size: int = 1000):
        self.cache = {}
        self.max_size = max_size
        self.access_count = {}
    
    def get(self, key: str):
        if key in self.cache:
            self.access_count[key] = self.access_count.get(key, 0) + 1
            return self.cache[key]
        return None
    
    def set(self, key: str, value):
        if len(self.cache) >= self.max_size:
            # Remove least frequently used item
            lfu_key = min(self.access_count.keys(), key=self.access_count.get)
            del self.cache[lfu_key]
            del self.access_count[lfu_key]
        
        self.cache[key] = value
        self.access_count[key] = 1

# Initialize cache
model_cache = ModelCache(max_size=500)
print("\nModel caching system initialized")

print("\nProduction environment deployment example completed")