Какая нейронная сеть использовалась на проекте?

Выбор и применение нейронных сетей в проектах

На проектах используются разные архитектуры нейронных сетей в зависимости от задачи. Как опытный разработчик, я расскажу о наиболее практичных подходах:

1. Классификация текста — Transformer модели

Для классификации, анализа эмоций, детектирования спама используют:

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Predefined модель (BERT, RoBERTa, DistilBERT)
model_name = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)

def classify_text(text):
    inputs = tokenizer(text, return_tensors="pt")
    with torch.no_grad():
        outputs = model(**inputs)
    
    logits = outputs.logits
    predicted_class = logits.argmax(-1).item()
    
    return {
        "text": text,
        "label": ["negative", "positive"][predicted_class],
        "confidence": torch.softmax(logits, dim=-1).max().item()
    }

# Использование
result = classify_text("This product is amazing!")
print(result)  # {'text': '...', 'label': 'positive', 'confidence': 0.98}

Почему Transformers?

• Лучшая точность для NLP задач
• Предобученные модели (transfer learning)
• Относительно быстрые для инференса
• Экосистема Hugging Face упрощает использование

2. Генерация текста — LLM models

Для чат-ботов, кодогенерации, обобщения используют:

from transformers import AutoTokenizer, AutoModelForCausalLM

# Использование готовой LLM
tokenizer = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2")

def generate_text(prompt, max_length=100):
    input_ids = tokenizer.encode(prompt, return_tensors="pt")
    
    output = model.generate(
        input_ids,
        max_length=max_length,
        num_beams=5,
        no_repeat_ngram_size=2,
        temperature=0.7
    )
    
    return tokenizer.decode(output[0], skip_special_tokens=True)

# Использование
text = generate_text("The future of AI is")
print(text)

3. Компьютерное зрение — CNNs

Для классификации, детектирования объектов:

from torchvision import models, transforms
from PIL import Image
import torch

# ResNet50 для классификации изображений
model = models.resnet50(pretrained=True)
model.eval()

# Предобработка
preprocess = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
])

def classify_image(image_path):
    image = Image.open(image_path)
    input_tensor = preprocess(image)
    input_batch = input_tensor.unsqueeze(0)
    
    with torch.no_grad():
        output = model(input_batch)
    
    probabilities = torch.nn.functional.softmax(output[0], dim=0)
    return probabilities.topk(5)

# Использование
image_path = "cat.jpg"
top_probs, top_classes = classify_image(image_path)

4. Рекомендации — Embedding models

Для рекомендационных систем:

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# Embedding модель
class EmbeddingModel:
    def __init__(self, embedding_dim=128):
        self.embedding_dim = embedding_dim
        # В реальном проекте используешь SentenceTransformer
        from sentence_transformers import SentenceTransformer
        self.model = SentenceTransformer('all-MiniLM-L6-v2')
    
    def get_embeddings(self, texts):
        """Получить embeddings для текстов"""
        return self.model.encode(texts, convert_to_tensor=True)
    
    def find_similar(self, query, candidates, top_k=5):
        """Найти похожие элементы"""
        query_embedding = self.get_embeddings([query])
        candidate_embeddings = self.get_embeddings(candidates)
        
        similarities = cosine_similarity(
            query_embedding,
            candidate_embeddings
        )[0]
        
        top_indices = np.argsort(similarities)[::-1][:top_k]
        return [(candidates[i], similarities[i]) for i in top_indices]

# Использование
model = EmbeddingModel()
results = model.find_similar(
    "cats are cute",
    ["dogs are loyal", "cats are cuddly", "birds can fly"],
    top_k=2
)

5. Временные ряды — RNN/LSTM/GRU

Для прогнозирования цен, нагрузки:

import torch
import torch.nn as nn

class LSTMPredictor(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super().__init__()
        self.lstm = nn.LSTM(
            input_size,
            hidden_size,
            num_layers,
            batch_first=True,
            dropout=0.2
        )
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        # x: (batch_size, seq_length, input_size)
        lstm_out, _ = self.lstm(x)
        # Берём последний выход
        last_hidden = lstm_out[:, -1, :]
        predictions = self.fc(last_hidden)
        return predictions

# Использование
model = LSTMPredictor(
    input_size=5,      # 5 фич
    hidden_size=64,    # 64 скрытых нейрона
    num_layers=2,      # 2 слоя LSTM
    output_size=1      # 1 прогноз
)

# Обучение
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(100):
    # Обучение на батчах...
    pass

6. Практический выбор архитектуры

# Матрица решений

def choose_architecture(task_type):
    architectures = {
        "text_classification": {
            "model": "BERT/RoBERTa/DistilBERT",
            "framework": "Hugging Face Transformers",
            "time_to_deploy": "1-2 дня",
            "accuracy": "95-98%"
        },
        "text_generation": {
            "model": "GPT-2/GPT-3/Llama",
            "framework": "Hugging Face Transformers",
            "time_to_deploy": "1 день",
            "accuracy": "зависит от промпта"
        },
        "image_classification": {
            "model": "ResNet/EfficientNet/ViT",
            "framework": "PyTorch/TensorFlow",
            "time_to_deploy": "2-3 дня",
            "accuracy": "90-99%"
        },
        "object_detection": {
            "model": "YOLOv8/Faster R-CNN",
            "framework": "PyTorch",
            "time_to_deploy": "3-5 дней",
            "accuracy": "85-95%"
        },
        "recommendation": {
            "model": "Embedding (SentenceTransformer)",
            "framework": "Hugging Face",
            "time_to_deploy": "1-2 дня",
            "accuracy": "зависит от метрики"
        },
        "time_series": {
            "model": "LSTM/GRU/Transformer",
            "framework": "PyTorch",
            "time_to_deploy": "3-5 дней",
            "accuracy": "80-95%"
        }
    }
    return architectures.get(task_type, {})

# Использование
config = choose_architecture("text_classification")
print(config)

Рекомендации по выбору

1. Начни с ready-to-use моделей: Hugging Face, OpenAI API
2. Transfer Learning: Fine-tune предобученные модели, не учи с нуля
3. Lightweight модели: DistilBERT вместо BERT, MobileNet вместо ResNet для продакшена
4. Тестируй на реальных данных: Точность на бенчмарке ≠ точность в продакшене
5. Мониторь дрифт: Модель деградирует со временем из-за дрифта данных
6. Используй фреймворки: ONNX для оптимизации и развёртывания