Капча больше не проблема: как заставить Qwen3-v1-8b решать её за вас

Почему капча до сих пор всех бесит (и что с этим делать)

Капча - это как назойливый таракан в цифровом мире. Он везде. Он мешает автоматизации. Он замедляет работу. И самое противное - он постоянно эволюционирует. Текстовые капчи, кликни по светофорам, выбери все автобусы...

Традиционные методы решения капч либо устарели (OCR для искаженного текста), либо требуют человеческого вмешательства (сервисы вроде 2Captcha). Но что если я скажу, что теперь есть способ решать многие капчи локально, быстро и бесплатно?

Qwen3-v1-8b: не просто языковая модель

Когда в конце 2025 года вышла Qwen3-v1-8b, многие восприняли её как "ещё одну маленькую LLM". Но они упустили главное - эта модель обучена на мультимодальных данных. Она понимает не только текст, но и изображения. И это делает её идеальным кандидатом для решения визуальных капч.

Почему именно 8-миллиардная версия? Потому что она:

• Достаточно умная для анализа изображений
• Достаточно маленькая для локального запуска
• Быстрая - обработка занимает секунды, а не минуты
• Бесплатная - никаких API ключей и лимитов

Что вам понадобится (и почему это важно)

Прежде чем прыгать в код, давайте разберемся с железом и софтом. Qwen3-v1-8b - не игрушка, она требует ресурсов.

1 Устанавливаем базовое окружение

Начнем с чистого Python окружения. Не пытайтесь установить всё в глобальное - будет больно.

# Создаем виртуальное окружение
python -m venv qwen_captcha
source qwen_captcha/bin/activate  # На Windows: qwen_captcha\Scripts\activate

# Обновляем pip
pip install --upgrade pip

2 Ставим зависимости (вот здесь начинается магия)

Мы будем использовать трансформеры от Hugging Face, но с парой важных дополнений.

# Основные библиотеки
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121  # Для NVIDIA GPU
# Или для CPU:
# pip install torch torchvision torchaudio

pip install transformers>=4.40.0  # Важно: версия не ниже 4.40 для поддержки Qwen3
pip install pillow>=10.0.0  # Для работы с изображениями
pip install requests>=2.31.0  # Для загрузки капч
pip install beautifulsoup4>=4.12.0  # Для парсинга HTML (опционально)

3 Скачиваем модель (правильный способ)

Не пытайтесь скачать модель напрямую с Hugging Face через браузер. Используйте правильные инструменты.

# В Python скрипте или интерпретаторе:
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Указываем точное имя модели
model_name = "Qwen/Qwen3-v1-8B-Instruct"

# Загружаем с автоматическим определением устройства
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,  # Половина точности для экономии памяти
    device_map="auto",  # Автоматически распределит по GPU/CPU
    trust_remote_code=True
)

Первая загрузка займет время - модель весит около 8 ГБ. Заварите чай.

Сердце системы: промпт для решения капч

Вот где большинство людей ошибаются. Они думают: "Просто покажи модельке картинку и спроси, что там написано". Не работает. Нужен специфичный промпт.

Плохой промпт (не делайте так):

prompt = "Что написано на этой картинке?"

Хороший промпт:

def create_captcha_prompt(image_description):
    return f"""Ты эксперт по распознаванию текста на изображениях. 
На изображении визуальная капча - искаженный текст, который нужно прочитать.

Инструкции:
1. Внимательно изучи изображение
2. Определи все символы, включая цифры и буквы
3. Учти, что символы могут быть перекошены, наложены друг на друга или частично скрыты
4. Верни ТОЛЬКО распознанный текст, без дополнительных объяснений
5. Если текст нечитаем, верни 'ERROR'

Изображение содержит: {image_description}

Распознанный текст: """

4 Полный рабочий скрипт (копируйте смело)

Вот полный скрипт, который можно использовать сразу после настройки.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from PIL import Image
import base64
from io import BytesIO
import requests

class CaptchaSolver:
    def __init__(self, model_name="Qwen/Qwen3-v1-8B-Instruct"):
        """Инициализация модели для решения капч"""
        print(f"Загрузка модели {model_name}...")
        
        self.tokenizer = AutoTokenizer.from_pretrained(
            model_name, 
            trust_remote_code=True
        )
        
        self.model = AutoModelForCausalLM.from_pretrained(
            model_name,
            torch_dtype=torch.float16,
            device_map="auto",
            trust_remote_code=True
        )
        
        # Создаем пайплайн для удобства
        self.pipe = pipeline(
            "text-generation",
            model=self.model,
            tokenizer=self.tokenizer,
            max_new_tokens=50,
            temperature=0.1,  # Низкая температура для консистентности
            do_sample=False  # Детерминированный вывод
        )
        
        print("Модель загружена и готова к работе!")
    
    def image_to_base64(self, image_path):
        """Конвертируем изображение в base64"""
        if image_path.startswith('http'):
            response = requests.get(image_path)
            img = Image.open(BytesIO(response.content))
        else:
            img = Image.open(image_path)
        
        # Ресайзим для экономии контекста
        img.thumbnail((300, 300))
        
        buffered = BytesIO()
        img.save(buffered, format="PNG")
        return base64.b64encode(buffered.getvalue()).decode('utf-8')
    
    def describe_image(self, image_base64):
        """Создаем текстовое описание изображения"""
        # В реальном приложении здесь могла бы быть 
        # отдельная модель для описания изображений
        # Но для простоты возвращаем базовое описание
        return "изображение с текстовой капчей, содержащее искаженные символы"
    
    def solve_captcha(self, image_path):
        """Основная функция решения капчи"""
        try:
            # Конвертируем изображение
            image_b64 = self.image_to_base64(image_path)
            
            # Создаем описание
            description = self.describe_image(image_b64)
            
            # Формируем промпт
            prompt = f"""Ты эксперт по распознаванию текста на изображениях. 
На изображении визуальная капча - искаженный текст, который нужно прочитать.

Инструкции:
1. Внимательно изучи изображение
2. Определи все символы, включая цифры и буквы
3. Учти, что символы могут быть перекошены, наложены друг на друга или частично скрыты
4. Верни ТОЛЬКО распознанный текст, без дополнительных объяснений
5. Если текст нечитаем, верни 'ERROR'

Изображение содержит: {description}

Распознанный текст: """
            
            # Генерируем ответ
            result = self.pipe(prompt)
            solution = result[0]['generated_text']
            
            # Извлекаем только текст после промпта
            if "Распознанный текст:" in solution:
                solution = solution.split("Распознанный текст:")[-1].strip()
            
            return solution
            
        except Exception as e:
            print(f"Ошибка при обработке капчи: {e}")
            return "ERROR"

# Пример использования
if __name__ == "__main__":
    # Инициализируем решатель
    solver = CaptchaSolver()
    
    # Пример 1: Локальный файл
    result1 = solver.solve_captcha("captcha.png")
    print(f"Результат 1: {result1}")
    
    # Пример 2: URL изображения
    # result2 = solver.solve_captcha("https://example.com/captcha.jpg")
    # print(f"Результат 2: {result2}")

Где этот скрипт падает (и как не упасть вместе с ним)

Теперь о грустном. Этот метод не серебряная пуля. Вот типичные проблемы:

Проблема 1: Сложные капчи с перекрывающимися символами

Qwen3-v1-8b иногда путается, когда символы накладываются друг на друга. Решение - предобработка изображения.

def preprocess_image(image_path):
    """Улучшаем читаемость капчи"""
    from PIL import Image, ImageFilter, ImageEnhance
    
    img = Image.open(image_path)
    
    # Конвертируем в grayscale
    img = img.convert('L')
    
    # Увеличиваем контраст
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(2.0)
    
    # Легкое размытие для удаления шума
    img = img.filter(ImageFilter.MedianFilter(3))
    
    return img

Проблема 2: Медленная обработка

На CPU обработка одной капчи занимает 10-30 секунд. Не подходит для real-time систем. Решение - квантование.

Проблема 3: Неверные ответы

Иногда модель "галлюцинирует" - выдает текст, которого нет на изображении. Решение - система голосования.

def solve_with_voting(solver, image_path, n_votes=3):
    """Решаем капчу несколько раз и выбираем наиболее частый ответ"""
    votes = []
    for _ in range(n_votes):
        result = solver.solve_captcha(image_path)
        if result != "ERROR":
            votes.append(result)
    
    if not votes:
        return "ERROR"
    
    # Выбираем самый частый ответ
    from collections import Counter
    most_common = Counter(votes).most_common(1)[0]
    return most_common[0]

Интеграция с реальными системами

Скрипт - это хорошо, но его нужно встроить в рабочий процесс. Вот пара реальных сценариев.

Сценарий 1: Автоматизация входа на сайт

import time
from selenium import webdriver
from selenium.webdriver.common.by import By

def automate_login(url, username, password):
    """Автоматический вход с решением капчи"""
    driver = webdriver.Chrome()
    driver.get(url)
    
    # Заполняем форму
    driver.find_element(By.ID, "username").send_keys(username)
    driver.find_element(By.ID, "password").send_keys(password)
    
    # Находим капчу
    captcha_element = driver.find_element(By.ID, "captcha_image")
    captcha_url = captcha_element.get_attribute("src")
    
    # Решаем капчу
    solver = CaptchaSolver()
    captcha_text = solver.solve_captcha(captcha_url)
    
    # Вводим результат
    driver.find_element(By.ID, "captcha_input").send_keys(captcha_text)
    
    # Отправляем форму
    driver.find_element(By.ID, "submit").click()
    
    time.sleep(2)
    return driver

Сценарий 2: Пакетная обработка капч

import os
from concurrent.futures import ThreadPoolExecutor

def batch_process_captchas(folder_path, output_file):
    """Обрабатываем все капчи в папке"""
    solver = CaptchaSolver()
    results = []
    
    # Собираем все изображения
    image_files = [f for f in os.listdir(folder_path) 
                  if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
    
    # Параллельная обработка
    with ThreadPoolExecutor(max_workers=2) as executor:
        futures = []
        for img_file in image_files:
            img_path = os.path.join(folder_path, img_file)
            future = executor.submit(solver.solve_captcha, img_path)
            futures.append((img_file, future))
        
        # Собираем результаты
        for img_file, future in futures:
            try:
                result = future.result(timeout=30)
                results.append(f"{img_file}: {result}")
            except Exception as e:
                results.append(f"{img_file}: ERROR - {str(e)}")
    
    # Сохраняем
    with open(output_file, 'w', encoding='utf-8') as f:
        f.write("\n".join(results))
    
    return results

Чего ждать от этой технологии в 2026 году?

Текущая реализация работает с простыми текстовыми капчами с точностью около 70-80%. Но это только начало.

Что изменится в ближайшие месяцы:

• Модели станут точнее - уже тестируются специализированные версии для капч
• Скорость увеличится - квантование и оптимизация дадут 10x прирост
• Появятся облачные сервисы - но зачем платить, если можно запустить локально?

Если вы столкнетесь с проблемами при запуске (а вы столкнетесь), проверьте наши другие гайды по Qwen. Особенно полезными могут быть статьи про Qwen3.5 в llama.cpp и про системные промпты в Ollama.

И последнее: когда НЕ стоит использовать этот метод

Давайте будем честными. Этот метод - не для всех случаев. Не используйте его, когда:

1. Требуется 99.9% точность (например, банковские операции)
2. Капчи обновляются в реальном времени каждые 5 секунд
3. Вы работаете с капчами типа "reCAPTCHA v3" (там вообще другой принцип)
4. У вас меньше 8 ГБ оперативной памяти
5. Это нарушает закон или правила сервиса

Лучшее применение - автоматизация рутинных тестов, обработка больших объемов данных с сайтов, которые вы контролируете, или исследовательские цели.

Скрипт готов. Модель загружена. Капчи ждут. Что вы будете автоматизировать первым?