Flux AI

Обзор Flux AI

Flux AI — это революционная потоковая мультимодальная нейросеть, способная обрабатывать и генерировать текст, изображения, аудио и видео в реальном времени. Основанная на архитектуре диффузионных трансформеров, Flux AI устанавливает новые стандарты в области генеративного искусственного интеллекта.

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

Диффузионные трансформеры

Flux AI использует инновационную архитектуру диффузионных трансформеров (Diffusion Transformers), которая объединяет:

• Многоуровневая диффузия — поэтапное преобразование шума в структурированные данные
• Трансформерные блоки — внимание к различным модальностям данных
• Потоковые слои — обработка данных по мере поступления
• Межмодальные связи — совместное обучение на различных типах данных

Технические характеристики

Ключевые особенности

Уникальные возможности Flux AI

• Потоковая генерация — начало вывода до завершения обработки всего промпта
• Межмодальные преобразования — текст в изображение, аудио в текст, видео в описание
• Контекстное редактирование — изменение существующего контента с сохранением контекста
• Стилевой перенос — применение стилей между различными модальностями
• Инкрементальное обучение — дообучение модели на новых данных без полного переобучения
• Распределенная генерация — параллельная обработка на нескольких GPU

Поддерживаемые задачи

Быстрый старт

pip install flux-ai

npm install @flux-ai/sdk

# Для работы напрямую через HTTP API

import os
from fluxai import Flux

# Инициализация клиента
flux = Flux(api_key=os.getenv("FLUX_API_KEY"))

# Потоковая генерация текста
stream = flux.text.generate(
    prompt="Напиши короткий рассказ о космическом путешествии",
    model="flux-pro",
    max_tokens=500,
    stream=True  # Включить потоковый вывод
)

# Чтение потока
for chunk in stream:
    print(chunk.text, end="", flush=True)
    # Обработка происходит в реальном времени

const { Flux } = require('@flux-ai/sdk');

// Инициализация клиента
const flux = new Flux({
    apiKey: process.env.FLUX_API_KEY
});

// Асинхронная генерация
async function generateStory() {
    const response = await flux.text.generate({
        prompt: "Напиши короткий рассказ о космическом путешествии",
        model: "flux-pro",
        maxTokens: 500
    });
    
    console.log(response.text);
}

generateStory().catch(console.error);

Доступные модели

Flux AI предлагает семейство моделей, оптимизированных для различных задач и бюджетов:

Специализированные модели

Справочник API

Базовые эндпоинты

POST https://api.flux.ai/v1/text/generate      # Генерация текста
POST https://api.flux.ai/v1/image/generate     # Генерация изображений
POST https://api.flux.ai/v1/audio/generate     # Генерация аудио
POST https://api.flux.ai/v1/video/generate     # Генерация видео
POST https://api.flux.ai/v1/multimodal/process # Мультимодальная обработка
GET  https://api.flux.ai/v1/models             # Список доступных моделей

Заголовки авторизации

Authorization: Bearer flux-XXXXXXXXXXXXXXXXXXXXXXXX
Content-Type: application/json
Flux-Version: 2024-03-01

Пример запроса генерации изображения

import base64
from fluxai import Flux

flux = Flux(api_key="your-api-key")

# Генерация изображения
response = flux.image.generate(
    prompt="Футуристический город ночью, неоновая подсветка, дождь",
    model="flux-vision",
    width=1024,
    height=768,
    steps=30,
    guidance_scale=7.5,
    style="cyberpunk",
    num_images=2
)

# Сохранение изображений
for i, image_data in enumerate(response.images):
    with open(f"image_{i}.png", "wb") as f:
        f.write(base64.b64decode(image_data))
    
    print(f"Изображение {i} сохранено")

# Метаданные
print(f"Seed: {response.seed}")
print(f"Время генерации: {response.generation_time}ms")

Параметры генерации

Мультимодальные возможности

Межмодальные преобразования

Flux AI поддерживает преобразования между различными типами данных:

from fluxai import Flux
import base64

flux = Flux(api_key="your-api-key")

# 1. Текст в изображение
image = flux.multimodal.transform(
    source_type="text",
    target_type="image",
    source="Кошка играет с клубком ниток в солнечной комнате",
    style="watercolor"
)

# 2. Изображение в описание
with open("cat.jpg", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

description = flux.multimodal.transform(
    source_type="image",
    target_type="text",
    source=image_data,
    prompt="Опиши это изображение детально"
)

# 3. Аудио в текст
with open("speech.wav", "rb") as f:
    audio_data = base64.b64encode(f.read()).decode()

transcript = flux.multimodal.transform(
    source_type="audio",
    target_type="text",
    source=audio_data,
    language="ru"
)

# 4. Текст в аудио (озвучка)
audio = flux.multimodal.transform(
    source_type="text",
    target_type="audio",
    source="Привет! Я Flux AI, современная нейросеть.",
    voice="female_01",
    emotion="happy"
)

Мультимодальный контекст

Flux AI позволяет работать со смешанным контекстом:

# Контекст с изображением и текстом
response = flux.multimodal.process(
    context=[
        {
            "type": "text",
            "content": "Это фотография моего кота."
        },
        {
            "type": "image",
            "content": image_data,  # base64 изображения
            "description": "Кот лежит на диване"
        },
        {
            "type": "text", 
            "content": "Напиши забавную подпись для этой фотографии."
        }
    ],
    model="flux-multimodal"
)

print(response.output)  # "Мой кот утверждает, что это его диван теперь!"

Примеры кода

Пример 1: Интерактивный чат с потоковой передачей

import asyncio
from fluxai import AsyncFlux

async def interactive_chat():
    """Интерактивный чат с потоковой передачей"""
    
    flux = AsyncFlux(api_key="your-api-key")
    
    # История сообщений
    messages = [
        {"role": "system", "content": "Ты полезный ассистент Flux AI."}
    ]
    
    print("🤖 Flux AI: Привет! Я готов помочь. Введите 'выход' для завершения.\n")
    
    while True:
        try:
            # Ввод пользователя
            user_input = input("\n👤 Вы: ").strip()
            
            if user_input.lower() in ['выход', 'exit', 'quit']:
                print("\n🤖 Flux AI: До свидания!")
                break
            
            # Добавляем сообщение пользователя
            messages.append({"role": "user", "content": user_input})
            
            # Потоковый ответ
            print("\n🤖 Flux AI: ", end="", flush=True)
            
            full_response = ""
            stream = await flux.chat.create(
                messages=messages,
                model="flux-pro",
                stream=True,
                temperature=0.8
            )
            
            async for chunk in stream:
                if chunk.text:
                    print(chunk.text, end="", flush=True)
                    full_response += chunk.text
            
            # Сохраняем ответ в историю
            messages.append({"role": "assistant", "content": full_response})
            print()  # Новая строка
            
        except KeyboardInterrupt:
            print("\n\nЗавершение...")
            break
        except Exception as e:
            print(f"\n⚠️ Ошибка: {e}")

# Запуск асинхронного чата
asyncio.run(interactive_chat())

Пример 2: Пакетная обработка изображений

const { Flux } = require('@flux-ai/sdk');
const fs = require('fs');
const path = require('path');

// Инициализация клиента
const flux = new Flux({
    apiKey: process.env.FLUX_API_KEY
});

async function batchProcessImages(prompts, outputDir) {
    /**
     * Пакетная генерация изображений
     * @param {Array} prompts - Массив промптов
     * @param {string} outputDir - Директория для сохранения
     */
    
    // Создаем директорию, если её нет
    if (!fs.existsSync(outputDir)) {
        fs.mkdirSync(outputDir, { recursive: true });
    }
    
    const results = [];
    
    // Ограничиваем параллельные запросы (5 одновременно)
    const batchSize = 5;
    
    for (let i = 0; i < prompts.length; i += batchSize) {
        const batch = prompts.slice(i, i + batchSize);
        const batchPromises = batch.map(async (prompt, index) => {
            try {
                console.log(`Генерация ${i + index + 1}/${prompts.length}: ${prompt.substring(0, 50)}...`);
                
                const response = await flux.image.generate({
                    prompt: prompt,
                    model: 'flux-vision',
                    width: 1024,
                    height: 1024,
                    style: 'digital-art',
                    guidanceScale: 7.5,
                    steps: 25
                });
                
                // Сохраняем изображение
                const filename = `image_${Date.now()}_${i + index}.png`;
                const filepath = path.join(outputDir, filename);
                
                // Декодируем base64 и сохраняем
                const buffer = Buffer.from(response.images[0], 'base64');
                fs.writeFileSync(filepath, buffer);
                
                results.push({
                    prompt: prompt,
                    filename: filename,
                    seed: response.seed,
                    success: true
                });
                
                return { success: true, prompt };
                
            } catch (error) {
                console.error(`Ошибка для промпта "${prompt}":`, error.message);
                results.push({
                    prompt: prompt,
                    error: error.message,
                    success: false
                });
                return { success: false, prompt, error: error.message };
            }
        });
        
        // Ждем завершения батча
        const batchResults = await Promise.allSettled(batchPromises);
        console.log(`Батч ${Math.floor(i / batchSize) + 1} завершен`);
        
        // Пауза между батчами для избежания rate limiting
        if (i + batchSize < prompts.length) {
            await new Promise(resolve => setTimeout(resolve, 1000));
        }
    }
    
    // Сохраняем метаданные
    const metadata = {
        generated_at: new Date().toISOString(),
        total_prompts: prompts.length,
        successful: results.filter(r => r.success).length,
        failed: results.filter(r => !r.success).length,
        results: results
    };
    
    fs.writeFileSync(
        path.join(outputDir, 'metadata.json'),
        JSON.stringify(metadata, null, 2)
    );
    
    return metadata;
}

// Пример использования
const prompts = [
    "Космический корабль в неоновых тонах",
    "Подводный город будущего",
    "Робот-художник рисует картину",
    "Лес светящихся грибов ночью",
    "Архитектура в стиле био-тек",
    "Магический портал в другом измерении",
    "Киберпанк улица в дождь",
    "Древний храм в джунглях",
    "Планета с двумя солнцами",
    "Стеклянный город на облаках"
];

batchProcessImages(prompts, './generated_images')
    .then(metadata => {
        console.log(`Готово! Успешно: ${metadata.successful}, Ошибок: ${metadata.failed}`);
    })
    .catch(console.error);

Лучшие практики

Оптимизация производительности

• Используйте потоковый режим — снижает воспринимаемую задержку
• Кэшируйте частые запросы — особенно для статического контента
• Пакетная обработка — объединяйте несколько запросов в один батч
• Выбирайте правильную модель — используйте flux-lite для простых задач
• Оптимизируйте промпты — четкие и конкретные промпты дают лучшие результаты

Обработка ошибок с повторными попытками

import time
import random
from fluxai import Flux, RateLimitError, ServerError

flux = Flux(api_key="your-api-key")

def robust_flux_request(prompt, max_retries=5, base_delay=1):
    """
    Устойчивый запрос к Flux API с экспоненциальной задержкой
    и случайным джиттером
    """
    
    for attempt in range(max_retries):
        try:
            response = flux.text.generate(
                prompt=prompt,
                model="flux-pro",
                max_tokens=500,
                temperature=0.7
            )
            return response.text
            
        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            
            # Экспоненциальная задержка с джиттером
            delay = base_delay * (2 ** attempt)
            jitter = random.uniform(0, 0.1 * delay)
            total_delay = delay + jitter
            
            print(f"Rate limit превышен. Попытка {attempt + 1}. "
                  f"Ждем {total_delay:.2f} секунд...")
            time.sleep(total_delay)
            
        except ServerError as e:
            if e.status_code >= 500:
                # Серверные ошибки - повторяем
                delay = base_delay * (2 ** attempt)
                print(f"Серверная ошибка. Повтор через {delay} секунд...")
                time.sleep(delay)
                continue
            else:
                raise  # Клиентские ошибки не повторяем
                
        except Exception as e:
            # Неожиданные ошибки
            if attempt == max_retries - 1:
                raise
            delay = base_delay * (2 ** attempt)
            print(f"Неожиданная ошибка: {e}. Повтор через {delay} секунд...")
            time.sleep(delay)
    
    raise Exception(f"Не удалось выполнить запрос после {max_retries} попыток")

# Использование
try:
    result = robust_flux_request(
        "Объясни теорию относительности простыми словами",
        max_retries=3
    )
    print(result)
except Exception as e:
    print(f"Ошибка: {e}")

Советы по промптам

Частые вопросы (FAQ)

Вопрос: Чем Flux AI отличается от других моделей?

Ответ: Flux AI отличается архитектурой диффузионных трансформеров, потоковой обработкой в реальном времени и нативной поддержкой мультимодальности в единой модели.

Вопрос: Можно ли использовать Flux локально?

Ответ: Да, Flux AI доступен для локального развертывания. Модели flux-nano и flux-lite могут работать на потребительском железе. Для более крупных моделей требуются мощные GPU.

Вопрос: Какие есть ограничения по использованию?

Ответ: Бесплатный тариф включает 1000 запросов в месяц. Платные тарифы имеют ограничения на основе выбранного плана. Все модели следуют политике этичного использования.

Вопрос: Поддерживает ли Flux русский язык?

Ответ: Да, Flux AI отлично работает с русским языком, а также поддерживает более 50 языков. Качество генерации на русском сопоставимо с английским.

Вопрос: Какой максимальный размер контекста?

Ответ: Модель flux-ultra поддерживает контекст до 1 миллиона токенов, что эквивалентно примерно 750 страницам текста.

Вопрос: Есть ли API для тонкой настройки?

Ответ: Да, Flux AI предоставляет API для тонкой настройки моделей на ваших данных. Это позволяет адаптировать модель под специфические задачи.