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

Интеграция нейросетей в backend проекты

Интеграция AI/ML моделей в Node.js backend — это становится всё более распространённой задачей. Есть несколько архитектурных подходов, каждый с плюсами и минусами.

Основные подходы

1. Прямая интеграция через npm библиотеки

Для простых моделей можно использовать библиотеки, которые работают прямо в Node.js.

TensorFlow.js — для запуска моделей в Node.js

import * as tf from '@tensorflow/tfjs';
import * as mobilenet from '@tensorflow-models/mobilenet';

class ImageClassificationService {
  private model: any;

  async initialize() {
    // Загружаем претренированную MobileNet модель
    this.model = await mobilenet.load();
  }

  async classifyImage(imageBuffer: Buffer): Promise<Classification[]> {
    const tensor = tf.node.decodeImage(imageBuffer, 3);
    const predictions = await this.model.classify(tensor);
    
    tensor.dispose(); // Важно! Освобождаем память
    
    return predictions;
  }
}

// API Endpoint
app.post('/api/v1/classify', async (req, res) => {
  try {
    const imageBuffer = req.file.buffer;
    const service = new ImageClassificationService();
    const results = await service.classifyImage(imageBuffer);
    
    res.json({ 
      status: 'success',
      classifications: results 
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

Плюсы:

• Всё в одном процессе
• Низкая latency
• Просто для прототипирования

Минусы:

• TensorFlow.js медленнее чем native реализации
• Блокирует основной event loop
• Сложно масштабировать на множество запросов

2. Вызов микросервиса с моделью (РЕКОМЕНДУЕТСЯ)

Больший проект: отделяем ML логику в отдельный микросервис. Это базовая архитектура в production.

// Node.js API микросервис
import axios from 'axios';

class AIService {
  private mlServiceUrl = process.env.ML_SERVICE_URL || 'http://ml-service:8000';

  async classifyText(text: string): Promise<Classification> {
    try {
      const response = await axios.post(
        `${this.mlServiceUrl}/classify`,
        { text },
        { timeout: 30000 } // 30 секунд timeout
      );
      
      return response.data;
    } catch (error) {
      throw new AIServiceError('Failed to classify text', error);
    }
  }

  async generateEmbedding(text: string): Promise<number[]> {
    const response = await axios.post(
      `${this.mlServiceUrl}/embed`,
      { text }
    );
    return response.data.embedding;
  }
}

// API endpoint
app.post('/api/v1/posts/:id/analyze', async (req, res) => {
  try {
    const post = await postService.getPost(req.params.id);
    const analysis = await aiService.classifyText(post.content);
    
    // Сохраняем результат в БД для кэширования
    await postService.updateAnalysis(post.id, analysis);
    
    res.json({ status: 'success', analysis });
  } catch (error) {
    logger.error('Post analysis failed', { error, postId: req.params.id });
    res.status(500).json({ error: 'Analysis failed' });
  }
});

Python ML сервис (FastAPI)

from fastapi import FastAPI
from transformers import pipeline
import logging

app = FastAPI()
logger = logging.getLogger(__name__)

# Загружаем модель один раз при старте
classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")

@app.post("/classify")
async def classify(request: ClassifyRequest):
    try:
        # Классификация текста
        candidate_labels = ["positive", "negative", "neutral"]
        result = classifier(
            request.text,
            candidate_labels,
            multi_class=True
        )
        
        return {
            "labels": result["labels"],
            "scores": result["scores"]
        }
    except Exception as e:
        logger.error(f"Classification failed: {e}")
        raise HTTPException(status_code=500, detail="Classification failed")

@app.post("/embed")
async def embed(request: EmbedRequest):
    try:
        from sentence_transformers import SentenceTransformer
        model = SentenceTransformer('all-MiniLM-L6-v2')
        embedding = model.encode(request.text).tolist()
        
        return {"embedding": embedding}
    except Exception as e:
        logger.error(f"Embedding failed: {e}")
        raise HTTPException(status_code=500, detail="Embedding failed")

Плюсы:

• Масштабируемо (можно запустить несколько инстансов ML сервиса)
• API server не блокируется
• Можно использовать GPU для ML сервиса
• Разные технологии для разных проблем

Минусы:

• Больше latency (сетевой вызов)
• Нужно управлять отдельным сервисом

3. Асинхронная обработка через очередь

Для долгих операций — используем очередь (Redis, RabbitMQ).

import Bull from 'bull';

// Создаём очередь для ML обработки
const mlQueue = new Bull('ml-processing', {
  redis: { host: '127.0.0.1', port: 6379 }
});

// API endpoint — добавляет задачу в очередь
app.post('/api/v1/documents/:id/analyze', async (req, res) => {
  try {
    const documentId = req.params.id;
    
    // Добавляем в очередь без ожидания
    const job = await mlQueue.add(
      { documentId },
      { 
        attempts: 3,
        backoff: { type: 'exponential', delay: 2000 },
        removeOnComplete: true
      }
    );
    
    res.json({ 
      status: 'processing',
      jobId: job.id,
      statusUrl: `/api/v1/jobs/${job.id}` 
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Worker обрабатывает задачи из очереди
mlQueue.process(async (job) => {
  try {
    const { documentId } = job.data;
    const document = await documentService.getDocument(documentId);
    
    // Долгая операция
    const analysis = await aiService.analyzeDocument(document.content);
    
    // Сохраняем результат
    await documentService.updateAnalysis(documentId, analysis);
    
    return { success: true, analysis };
  } catch (error) {
    throw error; // Bull автоматически переделает попытку
  }
});

// Polling для статуса
app.get('/api/v1/jobs/:id', async (req, res) => {
  try {
    const job = await mlQueue.getJob(req.params.id);
    
    if (!job) {
      return res.status(404).json({ error: 'Job not found' });
    }
    
    const state = await job.getState();
    const progress = job.progress();
    
    res.json({ 
      jobId: job.id,
      state,
      progress,
      data: job.data,
      result: job.returnvalue
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

Плюсы:

• API возвращает ответ мгновенно
• Можно обрабатывать большие батчи моделей
• Отказоустойчивость (retry при ошибке)

Минусы:

• Пользователь не видит результат сразу
• Нужна система polling или WebSocket для обновлений

4. Интеграция с облачными AI сервисами

Для масштабируемых проектов — используем готовые облачные сервисы.

import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
});

class ContentGenerationService {
  async generateBlogPost(title: string, topic: string): Promise<string> {
    const completion = await openai.chat.completions.create({
      model: 'gpt-4-turbo',
      messages: [
        {
          role: 'user',
          content: `Напиши статью на тему ${topic} с заголовком "${title}"`
        }
      ],
      temperature: 0.7,
      max_tokens: 2000
    });

    return completion.choices[0].message.content;
  }

  async summarizeText(text: string): Promise<string> {
    const completion = await openai.chat.completions.create({
      model: 'gpt-3.5-turbo',
      messages: [
        { role: 'user', content: `Суммаризируй этот текст:\n${text}` }
      ],
      temperature: 0.3,
      max_tokens: 500
    });

    return completion.choices[0].message.content;
  }
}

// API
app.post('/api/v1/generate/summary', async (req, res) => {
  try {
    const { text } = req.body;
    const summary = await contentService.summarizeText(text);
    
    res.json({ summary });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

Плюсы:

• Самые мощные модели
• Легко масштабируется
• Не нужно управлять инфраструктурой

Минусы:

• Дороговато (зависит от usage)
• Latency (сетевой запрос)
• Конфиденциальность данных

Практические рекомендации

Кэширование результатов

class AIServiceWithCache {
  async classifyText(text: string): Promise<Classification> {
    // Проверяем кэш
    const cacheKey = `classification:${md5(text)}`;
    const cached = await redis.get(cacheKey);
    
    if (cached) {
      return JSON.parse(cached);
    }
    
    // Делаем запрос в AI сервис
    const result = await aiService.classify(text);
    
    // Кэшируем на 24 часа
    await redis.setex(cacheKey, 86400, JSON.stringify(result));
    
    return result;
  }
}

Обработка ошибок и retry

class ResilientAIService {
  async callWithRetry(
    fn: () => Promise<any>,
    maxAttempts = 3,
    delayMs = 1000
  ): Promise<any> {
    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
      try {
        return await fn();
      } catch (error) {
        if (attempt === maxAttempts) throw error;
        
        logger.warn(`Attempt ${attempt} failed, retrying in ${delayMs}ms`, error);
        await new Promise(resolve => setTimeout(resolve, delayMs));
      }
    }
  }
}

Мониторинг

app.post('/api/v1/posts/analyze', async (req, res) => {
  const startTime = Date.now();
  
  try {
    const analysis = await aiService.analyze(req.body.content);
    
    // Логируем успех
    metrics.recordAILatency(Date.now() - startTime, 'success');
    
    res.json({ analysis });
  } catch (error) {
    metrics.recordAILatency(Date.now() - startTime, 'error');
    metrics.incrementAIErrors('analyze');
    
    res.status(500).json({ error: error.message });
  }
});

Архитектурный выбор

Подход             Latency  Scalability  Complexity  Cost
──────────────────────────────────────────────────────────
ТensorFlow.js       Low      Low          Low         Free
Mикросервис ML      Med      High         Med         Med
Очередь            High      High         Med         Low
Облачный API       Med      Very High    Low         High

Для production обычно используют комбинацию: микросервис ML для высоконагруженных операций + облачные API для специализированных задач (генерация, перевод) + очередь для долгих батчей.

Профессиональный backend-разработчик понимает не только как вызвать AI модель, но и как масштабировать, кэшировать, мониторить и обрабатывать ошибки при её использовании.