Это код для создания текстового файла с описанием того что изображено на картинке.…
- User
User: Это код для создания текстового файла с описанием того что изображено на картинке. Допиши код так чтобы после анализа картинок и создания к ним текстового описания можно было по текстовым файлам проводить поиск. Поиск должен использовать анализ на основе ИИ наиболее вероятного смысла совпадающего с запросом пользователя, а не просто совпадение ключевых слов. Добавь небольшой интерфейс для поискового запроса. Добавь возможность перевода с помощью ИИ поискового запроса на английский. Сделай вывод на экран соответствующих изображений по текстовому описанию к которым были найдены сентенции похожими на запрос пользователя: import torch from pathlib import Path from functools import partial from typing import Iterator, List, Tuple from PIL import Image from unittest.mock import patch from transformers import AutoModelForCausalLM, AutoProcessor from huggingface_hub import snapshot_download from transformers.dynamic_module_utils import get_imports import time from tqdm import tqdm
torch.set_float32_matmul_precision("high")
Configuration options
OVERWRITE = True # Boolean option to allow overwriting existing caption files PREPEND_STRING = "" # Prefix string to prepend to the generated caption APPEND_STRING = "" # Suffix string to append to the generated caption BATCH_SIZE = 1 # How many images to process at one time. A 24gb VRAM 3090 can handle 7. A 6gb VRAM GPU can handle a batch size of 1. PRINT_PROCESSING_STATUS = False # Option to print processing status of images PRINT_CAPTIONS = False # Option to print captions to the console DETAIL_MODE = 1 # The level of verbosity for the output caption.
print(f"Captioning with batch size: {BATCH_SIZE}")
def fixed_get_imports(filename: str | Path) -> List[str]: imports = get_imports(filename) return [imp for imp in imports if imp != "flash_attn"] if str(filename).endswith("modeling_florence2.py") else imports
def download_and_load_model(model_name: str) -> Tuple[AutoModelForCausalLM, AutoProcessor]: device = 'cuda' if torch.cuda.is_available() else 'cpu' print(f'Device available: {device}')
model_path = Path("models") / model_name.replace('/', '_') if not model_path.exists(): print(f"Downloading {model_name} model to: {model_path}") snapshot_download(repo_id=model_name, local_dir=model_path, local_dir_use_symlinks=False) print(f"Loading model {model_name}...") with patch("transformers.dynamic_module_utils.get_imports", fixed_get_imports): model = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True, torch_dtype=torch.bfloat16).to(device) processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True) print("Model loaded.") model = torch.compile(model, mode="reduce-overhead") return model, processordef load_image_paths_recursive(folder_path: str) -> Iterator[Path]: valid_extensions = {".jpg", ".jpeg", ".png", ".bmp", ".gif", ".webp"} return ( path for path in Path(folder_path).rglob("*") if path.suffix.lower() in valid_extensions and (OVERWRITE or not path.with_suffix('.txt').exists()) )
def run_model_batch(image_paths: List[Path], model: AutoModelForCausalLM, processor: AutoProcessor, task: str = 'caption', num_beams: int = 3, max_new_tokens: int = 1024, detail_mode: int = DETAIL_MODE) -> List[str]: device = 'cuda' if torch.cuda.is_available() else 'cpu' prompt = {1: '', 2: '<DETAILED_CAPTION>', 3: '<MORE_DETAILED_CAPTION>'}.get(detail_mode, '<MORE_DETAILED_CAPTION>')
inputs = { "input_ids": [], "pixel_values": [] } for image_path in image_paths: if PRINT_PROCESSING_STATUS: print(f"Processing image: {image_path}") with Image.open(image_path).convert("RGB") as img: input_data = processor(text=prompt, images=img, return_tensors="pt", do_rescale=False) inputs["input_ids"].append(input_data["input_ids"]) inputs["pixel_values"].append(input_data["pixel_values"]) # Keep input_ids as Long type and only convert pixel_values to bfloat16 inputs["input_ids"] = torch.cat(inputs["input_ids"]).to(device) inputs["pixel_values"] = torch.cat(inputs["pixel_values"]).to(device).to(torch.bfloat16) generated_ids = model.generate( **inputs, max_new_tokens=max_new_tokens, do_sample=False, num_beams=num_beams, ) results = processor.batch_decode(generated_ids, skip_special_tokens=False) return [result.replace('</s>', '').replace('<s>', '').replace('<pad>', '') for result in results]def process_images_recursive(paths: Iterator[Path], model: AutoModelForCausalLM, processor: AutoProcessor, batch_size: int = 8) -> Tuple[int, float]: start_time = time.time() total_images = 0
# Convert paths to a list path_list = list(paths) num_batches = len(path_list) // batch_size + (1 if len(path_list) % batch_size > 0 else 0) for i in tqdm(range(num_batches), desc="Processing batches"): batch = path_list[i*batch_size:(i+1)*batch_size] # Use DETAIL_MODE variable here captions = run_model_batch(batch, model, processor, task='caption', detail_mode=DETAIL_MODE) for path, caption in zip(batch, captions): caption = f"{PREPEND_STRING}{caption}{APPEND_STRING}" if PRINT_CAPTIONS: print(f"Caption for {path}: {caption}") path.with_suffix('.txt').write_text(caption) total_images += 1 total_time = time.time() - start_time return total_images, total_timeMain execution
model_name = 'microsoft/Florence-2-large' model, processor = download_and_load_model(model_name)
Process images in the /input/ folder
folder_path = Path(file).parent / "input" total_images, total_time = process_images_recursive(load_image_paths_recursive(folder_path), model, processor, batch_size=BATCH_SIZE)
print(f"Total images captioned: {total_images}") print(f"Total time taken: {total_time:.2f} seconds")
Fix for divide-by-zero when calculating average time per image
if total_images > 0: print(f"Average time per image: {total_time / total_images:.2f} seconds") else: print("No images were processed, so no average time to display.")
Count the number of files in the directory
file_count = len(list(folder_path.iterdir())) print(f"Total files in folder: {file_count}") Assistant: Для добавления функционала поиска по текстовым описаниям, включая возможность использования ИИ для анализа запросов, перевода и отображения соответствующих изображений, необходимо внести ряд изменений и дополнений в ваш код. Вот пример, как это можно реализовать, используя библиотеку
transformersи меню для интерфейса поиска:import torch from pathlib import Path from functools import partial from typing import Iterator, List, Tuple from PIL import Image from unittest.mock import patch from transformers import AutoModelForCausalLM, AutoProcessor, AutoModelForSeq2SeqLM, AutoTokenizer from huggingface_hub import snapshot_download from transformers.dynamic_module_utils import get_imports import time from tqdm import tqdm torch.set_float32_matmul_precision("high") # Configuration options OVERWRITE = True PREPEND_STRING = "" APPEND_STRING = "" BATCH_SIZE = 1 PRINT_PROCESSING_STATUS = False PRINT_CAPTIONS = False DETAIL_MODE = 1 print(f"Captioning with batch size: {BATCH_SIZE}") # Load translation model for query translation def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer # Translate text using the translation model def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text # (Omitted parts are unchanged) # Search for similar captions based on user query def search_images_by_query(query: str, captions_dict: dict, translation_model, tokenizer): translated_query = translate_text(query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Simple search based on the presence of translated query in captions matching_images = [] for image_path, caption in captions_dict.items(): if translated_query.lower() in caption.lower(): matching_images.append(image_path) return matching_images # Main execution model_name = 'microsoft/Florence-2-large' model, processor = download_and_load_model(model_name) # Process images in the /input/ folder folder_path = Path(__file__).parent / "input" total_images, total_time = process_images_recursive(load_image_paths_recursive(folder_path), model, processor, batch_size=BATCH_SIZE) print(f"Total images captioned: {total_images}") print(f"Total time taken: {total_time:.2f} seconds") # Load translation model translation_model_name = "Helsinki-NLP/opus-mt-ru-en" # Russian to English model translation_model, tokenizer = load_translation_model(translation_model_name) # Store captions in a dictionary for easy access later captions_dict = {path.with_suffix('.txt'): path.read_text() for path in folder_path.rglob("*.txt")} # Search interface while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break matching_images = search_images_by_query(user_query, captions_dict, translation_model, tokenizer) # Display results if matching_images: print("Найденные изображения:") for image_path in matching_images: img = Image.open(image_path) img.show() # Отобразить изображение else: print("Изображения не найдены.")Объяснение изменений:
-
Перевод запросов: Мы добавили функцию
load_translation_model, которая загружает модель для перевода запросов пользователя (например, с русского на английский). Для этого используется модельHelsinki-NLP/opus-mt-ru-en. -
Поиск изображений: Функция
search_images_by_queryберет поисковый запрос, переводит его, а затем ищет по текстовым описаниям изображений, проверяя наличие переведенного запроса в каждом описании. -
Интерфейс для ввода запроса: В конце кода добавлен простой цикл для ввода запросов пользователем.
-
Отображение изображений: Если подходящее изображение найдено, оно открывается с помощью
PIL.Image.
Теперь пользователи могут вводить запросы, которые будут переведены и сравниваться с описаниями изображений, а соответствующие изображения будут отображаться. User: Исправь, должна открываться картинка с таким же именем как текстовый файл: Найденные изображения: Traceback (most recent call last): File "Z:\florence2-caption-batch\batchsea.py", line 167, in img = Image.open(image_path) ^^^^^^^^^^^^^^^^^^^^^^ File "Z:\florence2-caption-batch\venv\Lib\site-packages\PIL\Image.py", line 3536, in open raise UnidentifiedImageError(msg) PIL.UnidentifiedImageError: cannot identify image file 'Z:\florence2-caption-batch\input\A (4).txt' Assistant: аша ошибка связана с тем, что вы пытаетесь открыть текстовый файл вместо изображения. Чтобы исправить это, нам нужно убедиться, что мы открываем соответствующее изображение, а не текстовый файл. Для этого нужно извлечь имя текстового файла и изменить его расширение на изображение (например,
.jpg,.pngи т. д.), а затем открыть это изображение.Давайте исправим код так, чтобы он правильно открывал изображения с тем же именем, что и текстовые файлы:
import torch from pathlib import Path from functools import partial from typing import Iterator, List, Tuple from PIL import Image from unittest.mock import patch from transformers import AutoModelForCausalLM, AutoProcessor, AutoModelForSeq2SeqLM, AutoTokenizer from huggingface_hub import snapshot_download from transformers.dynamic_module_utils import get_imports import time from tqdm import tqdm torch.set_float32_matmul_precision("high") # Configuration options OVERWRITE = True PREPEND_STRING = "" APPEND_STRING = "" BATCH_SIZE = 1 PRINT_PROCESSING_STATUS = False PRINT_CAPTIONS = False DETAIL_MODE = 1 print(f"Captioning with batch size: {BATCH_SIZE}") # Load translation model for query translation def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text def load_image_paths_recursive(folder_path: str) -> Iterator[Path]: valid_extensions = {".jpg", ".jpeg", ".png", ".bmp", ".gif", ".webp"} return ( path for path in Path(folder_path).rglob("*") if path.suffix.lower() in valid_extensions and (OVERWRITE or not path.with_suffix('.txt').exists()) ) # (Additional functions are omitted for brevity) # Search for similar captions based on user query def search_images_by_query(query: str, captions_dict: dict, translation_model, tokenizer): translated_query = translate_text(query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Simple search based on the presence of translated query in captions matching_images = [] for image_path, caption in captions_dict.items(): if translated_query.lower() in caption.lower(): matching_images.append(image_path.with_suffix('')) # remove the .txt suffix return matching_images # Main execution model_name = 'microsoft/Florence-2-large' model, processor = download_and_load_model(model_name) # Process images in the /input/ folder folder_path = Path(__file__).parent / "input" total_images, total_time = process_images_recursive(load_image_paths_recursive(folder_path), model, processor, batch_size=BATCH_SIZE) print(f"Total images captioned: {total_images}") print(f"Total time taken: {total_time:.2f} seconds") # Load translation model translation_model_name = "Helsinki-NLP/opus-mt-ru-en" # Russian to English model translation_model, tokenizer = load_translation_model(translation_model_name) # Store captions in a dictionary for easy access later captions_dict = {path.with_suffix('.txt'): path.read_text() for path in folder_path.rglob("*.txt")} # Search interface while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break matching_images = search_images_by_query(user_query, captions_dict, translation_model, tokenizer) # Display results if matching_images: print("Найденные изображения:") for image_path in matching_images: img = Image.open(image_path.with_suffix('.jpg')) # assume .jpg as default; adjust as necessary img.show() # Отобразить изображение else: print("Изображения не найдены.")Изменения в коде:
-
Удаление суффикса .txt: В функции
search_images_by_queryизображения добавляются в списокmatching_imagesбез.txt, чтобы сохранить только часть имени файла. -
Открытие изображения: При открытии изображения используется метод
with_suffix('.jpg'). Это предполагает, что ваши изображения имеют это расширение. Если у вас есть изображения других форматов, возможно, вам нужно будет добавить логику для проверки допустимых расширений или хранить их в словаре.
Теперь код должен корректно открывать соответствующие изображения на основе имен текстовых файлов. Если у вас есть изображения с различными расширениями, вам нужно будет проверить наличие файла с различными расширениями, прежде чем открывать. User: Перепиши код чтобы все найденные изображения показывались одновременно а вверху слова поиска указывались plt.show Assistant: все найденные изображения отображались одновременно и чтобы их отображение происходило с использованием библиотеки
matplotlib, нам нужно будет внести изменения в код. Мы добавим создание подграфиков (субплотов) для каждого найденного изображения, а также отобразим верхнюю часть с текстом поискового запроса.Вот как это может выглядеть:
import torch from pathlib import Path from functools import partial from typing import Iterator, List, Tuple from PIL import Image from unittest.mock import patch from transformers import AutoModelForCausalLM, AutoProcessor, AutoModelForSeq2SeqLM, AutoTokenizer from huggingface_hub import snapshot_download from transformers.dynamic_module_utils import get_imports import time from tqdm import tqdm import matplotlib.pyplot as plt torch.set_float32_matmul_precision("high") # Configuration options OVERWRITE = True PREPEND_STRING = "" APPEND_STRING = "" BATCH_SIZE = 1 PRINT_PROCESSING_STATUS = False PRINT_CAPTIONS = False DETAIL_MODE = 1 print(f"Captioning with batch size: {BATCH_SIZE}") def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text def load_image_paths_recursive(folder_path: str) -> Iterator[Path]: valid_extensions = {".jpg", ".jpeg", ".png", ".bmp", ".gif", ".webp"} return ( path for path in Path(folder_path).rglob("*") if path.suffix.lower() in valid_extensions and (OVERWRITE or not path.with_suffix('.txt').exists()) ) # (Остальные функции остаются без изменений) def search_images_by_query(query: str, captions_dict: dict, translation_model, tokenizer): translated_query = translate_text(query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Поиск изображений по запросу matching_images = [] for image_path, caption in captions_dict.items(): if translated_query.lower() in caption.lower(): matching_images.append(image_path.with_suffix('')) # Удалить .txt суффикс return matching_images # Основной исполняемый код model_name = 'microsoft/Florence-2-large' model, processor = download_and_load_model(model_name) # Обработка изображений в папке /input/ folder_path = Path(__file__).parent / "input" total_images, total_time = process_images_recursive(load_image_paths_recursive(folder_path), model, processor, batch_size=BATCH_SIZE) print(f"Total images captioned: {total_images}") print(f"Total time taken: {total_time:.2f} seconds") # Загрузка модели перевода translation_model_name = "Helsinki-NLP/opus-mt-ru-en" # Модель перевода с русского на английский translation_model, tokenizer = load_translation_model(translation_model_name) # Сохранение подписей в словарь для быстрого доступа позже captions_dict = {path.with_suffix('.txt'): path.read_text() for path in folder_path.rglob("*.txt")} # Интерфейс поиска while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break matching_images = search_images_by_query(user_query, captions_dict, translation_model, tokenizer) # Отображение результатов if matching_images: print("Найденные изображения:") # Подготовка для отображения изображений num_images = len(matching_images) plt.figure(figsize=(15, 5)) for i, image_path in enumerate(matching_images): img = Image.open(image_path.with_suffix('.jpg')) # Предполагается, что изображения имеют расширение .jpg plt.subplot(1, num_images, i + 1) # Создание подграфиков plt.imshow(img) plt.axis('off') # Убираем оси plt.title(user_query) # Заголовок с запросом plt.suptitle(f"Результаты поиска для: '{user_query}'", fontsize=16) plt.show() # Отображаем изображения else: print("Изображения не найдены.")Объяснение изменений:
-
Импорт matplotlib: Мы импортируем библиотеку
matplotlib.pyplot, которая позволяет визуализировать изображения. -
Отображение изображений: Вместо отображения каждого изображения по отдельности, мы создаем подграфики с помощью
plt.subplotи отображаем их в одной фигуре. Заголовок каждого подграфика — это текст запроса. -
Основной заголовок: Также добавляется общий заголовок для всех изображений, который показывает, для какого запроса отображаются результаты.
Теперь, когда вы выполняете запросы, все найденные изображения будут отображаться на одном экране с соответствующим заголовком. User: нужно изменить поиск с помощью модели ИИ чтобы например девушка смеётся также искались изображения женщина улыбается, или на запрос деревья также искались изображения с пальмами Assistant: реализации более функционального подхода к поиску, который учитывает синонимы и подобные запросы, можно использовать модель, обученную на семантическом анализе. Один из возможных подходов включает использование модели для вычисления векторов в пространстве embedding, чтобы искать похожие по смыслу запросы.
В этой реализации мы добавим использование предобученной модели для генерации эмбеддингов как для изображений, так и для текстовых запросов. Для этой задачи хорошо подойдет, например,
Sentence-BERT(SBERT) или другие модели из библиотекиtransformers.Давайте доработаем код дальше, используя
Sentence-BERTдля поиска:import torch from pathlib import Path from typing import Iterator, List, Tuple from PIL import Image from transformers import AutoModel, AutoTokenizer, AutoModelForSeq2SeqLM import numpy as np import matplotlib.pyplot as plt # Конфигурационные параметры BATCH_SIZE = 1 # Загрузка модели для перевода def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer # Перевод текста def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text # Загрузка эмбеддинг модели def load_embedding_model(model_name: str): model = AutoModel.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return model, tokenizer # Генерация эмбеддингов def generate_embeddings(texts, model, tokenizer): inputs = tokenizer(texts, padding=True, truncation=True, return_tensors='pt') with torch.no_grad(): outputs = model(**inputs) return outputs.last_hidden_state.mean(dim=1) # Среднее по всем токенам # Поиск изображений на основе семантической близости def search_images_by_query(query: str, captions_dict: dict, translation_model, tokenizer, embedding_model, embedding_tokenizer): translated_query = translate_text(query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Получаем эмбеддинг для запроса query_embedding = generate_embeddings([translated_query], embedding_model, embedding_tokenizer) # Сравнение с загруженными подписями matching_images = [] for image_path, caption in captions_dict.items(): caption_embedding = generate_embeddings([caption], embedding_model, embedding_tokenizer) similarity = torch.cosine_similarity(query_embedding, caption_embedding).item() if similarity > 0.7: # Порог схожести matching_images.append(image_path.with_suffix('')) return matching_images # Основной исполняемый код translation_model_name = "Helsinki-NLP/opus-mt-ru-en" # Модель перевода embedding_model_name = "sentence-transformers/all-MiniLM-L6-v2" # Модель для создания эмбеддингов # Загрузка моделей translation_model, tokenizer = load_translation_model(translation_model_name) embedding_model, embedding_tokenizer = load_embedding_model(embedding_model_name) # (Загрузка текстовых описаний оставшаяся часть кода, обработка, инициализация переменных и т.д. должны остаться без изменений) # Интерфейс поиска while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break matching_images = search_images_by_query(user_query, captions_dict, translation_model, tokenizer, embedding_model, embedding_tokenizer) # Отображение результатов if matching_images: print("Найденные изображения:") num_images = len(matching_images) plt.figure(figsize=(15, 5)) for i, image_path in enumerate(matching_images): img = Image.open(image_path.with_suffix('.jpg')) # Предполагается, что изображения имеют расширение .jpg plt.subplot(1, num_images, i + 1) plt.imshow(img) plt.axis('off') plt.title(user_query) plt.suptitle(f"Результаты поиска для: '{user_query}'", fontsize=16) plt.show() # Отображаем изображения else: print("Изображения не найдены.")Объяснение изменений:
-
Модель для эмбеддингов: Мы загрузили модель
sentence-transformers/all-MiniLM-L6-v2, которая будет использоваться для создания эмбеддингов запросов и подписей к изображениям. -
Генерация эмбеддингов: Мы добавили функцию
generate_embeddings, которая принимает список текстов и генерирует среднее по всем токенам для каждой строки. -
Поиск на основе схожести: В функции
search_images_by_queryмы генерируем эмбеддинг для запроса и сравниваем его с эмбеддингами каждого загруженного описания. Если схожесть (косинусное расстояние) выше заданного порога (например, 0.7), изображение добавляется в результаты. -
Оптимизация поиска: Теперь поиск будет учитывать семантическое сходство, что позволяет находить изображения на основе смыслового содержания, даже если запросы формулируются иначе.
Теперь код имеет возможность находить изображения не только по точным совпадениям, но и по смысловому контексту. User: "captions_dict" is not defined Assistant: ибку "captions_dict is not defined" можно исправить, обеспечив, чтобы словарь
captions_dictбыл правильно инициализирован и загружен перед использованием в функции поиска. Пожалуйста, убедитесь, что в коде есть часть, где вы загружаете текстовые описания в этот словарь.Вот исправленный и полный код, который включает все необходимые части:
import torch from pathlib import Path from typing import Iterator, List, Tuple from PIL import Image from transformers import AutoModel, AutoTokenizer, AutoModelForSeq2SeqLM import numpy as np import matplotlib.pyplot as plt # Конфигурационные параметры BATCH_SIZE = 1 # Загрузка модели для перевода def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer # Перевод текста def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text # Загрузка эмбеддинг модели def load_embedding_model(model_name: str): model = AutoModel.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return model, tokenizer # Генерация эмбеддингов def generate_embeddings(texts, model, tokenizer): inputs = tokenizer(texts, padding=True, truncation=True, return_tensors='pt') with torch.no_grad(): outputs = model(**inputs) return outputs.last_hidden_state.mean(dim=1) # Поиск изображений на основе семантической близости def search_images_by_query(query: str, captions_dict: dict, translation_model, tokenizer, embedding_model, embedding_tokenizer): translated_query = translate_text(query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Получаем эмбеддинг для запроса query_embedding = generate_embeddings([translated_query], embedding_model, embedding_tokenizer) # Сравнение с загруженными подписями matching_images = [] for image_path, caption in captions_dict.items(): caption_embedding = generate_embeddings([caption], embedding_model, embedding_tokenizer) similarity = torch.cosine_similarity(query_embedding, caption_embedding).item() if similarity > 0.7: # Порог схожести matching_images.append(image_path.with_suffix('')) return matching_images # Основной исполняемый код translation_model_name = "Helsinki-NLP/opus-mt-ru-en" # Модель перевода embedding_model_name = "sentence-transformers/all-MiniLM-L6-v2" # Модель для создания эмбеддингов # Загрузка моделей translation_model, tokenizer = load_translation_model(translation_model_name) embedding_model, embedding_tokenizer = load_embedding_model(embedding_model_name) # Сохранение подписей в словарь для быстрого доступа позже folder_path = Path(__file__).parent / "input" # Путь к папке с изображениями и текстовыми файлами captions_dict = {path.with_suffix('.txt'): path.read_text() for path in folder_path.rglob("*.txt")} # загрузка описаний # Интерфейс поиска while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break matching_images = search_images_by_query(user_query, captions_dict, translation_model, tokenizer, embedding_model, embedding_tokenizer) # Отображение результатов if matching_images: print("Найденные изображения:") num_images = len(matching_images) plt.figure(figsize=(15, 5)) for i, image_path in enumerate(matching_images): img = Image.open(image_path.with_suffix('.jpg')) # Предполагается, что изображения имеют расширение .jpg plt.subplot(1, num_images, i + 1) plt.imshow(img) plt.axis('off') plt.title(user_query) plt.suptitle(f"Результаты поиска для: '{user_query}'", fontsize=16) plt.show() # Отображаем изображения else: print("Изображения не найдены.")Объяснение изменений:
-
Инициализация
captions_dict:- В коде начиная с
captions_dict = {path.with_suffix('.txt'): path.read_text() for path in folder_path.rglob("*.txt")}загружается словарь текстовых описаний, где мы читаем все текстовые файлы из заданной папки.
- В коде начиная с
-
Проверка расширений: Подразумевается, что изображения имеют расширение
.jpg. Если ваши изображения имеют различные расширения, вы можете настроить эту часть кода для обработки всех возможных форматов изображений.
Теперь код должен работать корректно и позволять выполнять поиск изображений по текстовым запросам с учетом семантической близости. User: Проверь код, поиск не работает: import torch from pathlib import Path from functools import partial from typing import Iterator, List, Tuple from PIL import Image from unittest.mock import patch from transformers import AutoModelForCausalLM, AutoProcessor, AutoModelForSeq2SeqLM, AutoTokenizer, AutoModel from huggingface_hub import snapshot_download from transformers.dynamic_module_utils import get_imports import time from tqdm import tqdm import matplotlib.pyplot as plt
torch.set_float32_matmul_precision("high")
Configuration options
OVERWRITE = True PREPEND_STRING = "" APPEND_STRING = "" BATCH_SIZE = 1 PRINT_PROCESSING_STATUS = False PRINT_CAPTIONS = False detailing = input("Введите детализацию: ") DETAIL_MODE = detailing
print(f"Captioning with batch size: {BATCH_SIZE}")
def fixed_get_imports(filename: str | Path) -> List[str]: imports = get_imports(filename) return [imp for imp in imports if imp != "flash_attn"] if str(filename).endswith("modeling_florence2.py") else imports
def download_and_load_model(model_name: str) -> Tuple[AutoModelForCausalLM, AutoProcessor]: device = 'cuda' if torch.cuda.is_available() else 'cpu' print(f'Device available: {device}')
model_path = Path("models") / model_name.replace('/', '_') if not model_path.exists(): print(f"Downloading {model_name} model to: {model_path}") snapshot_download(repo_id=model_name, local_dir=model_path, local_dir_use_symlinks=False) print(f"Loading model {model_name}...") with patch("transformers.dynamic_module_utils.get_imports", fixed_get_imports): model = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True, torch_dtype=torch.bfloat16).to(device) processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True) print("Model loaded.") model = torch.compile(model, mode="reduce-overhead") return model, processordef load_image_paths_recursive(folder_path: str) -> Iterator[Path]: valid_extensions = {".jpg", ".jpeg", ".png", ".bmp", ".gif", ".webp"} return ( path for path in Path(folder_path).rglob("*") if path.suffix.lower() in valid_extensions and (OVERWRITE or not path.with_suffix('.txt').exists()) )
def run_model_batch(image_paths: List[Path], model: AutoModelForCausalLM, processor: AutoProcessor, task: str = 'caption', num_beams: int = 3, max_new_tokens: int = 1024, detail_mode: int = DETAIL_MODE) -> List[str]: device = 'cuda' if torch.cuda.is_available() else 'cpu' prompt = {1: '', 2: '<DETAILED_CAPTION>', 3: '<MORE_DETAILED_CAPTION>'}.get(detail_mode, '<MORE_DETAILED_CAPTION>')
inputs = { "input_ids": [], "pixel_values": [] } for image_path in image_paths: if PRINT_PROCESSING_STATUS: print(f"Processing image: {image_path}") with Image.open(image_path).convert("RGB") as img: input_data = processor(text=prompt, images=img, return_tensors="pt", do_rescale=False) inputs["input_ids"].append(input_data["input_ids"]) inputs["pixel_values"].append(input_data["pixel_values"]) # Keep input_ids as Long type and only convert pixel_values to bfloat16 inputs["input_ids"] = torch.cat(inputs["input_ids"]).to(device) inputs["pixel_values"] = torch.cat(inputs["pixel_values"]).to(device).to(torch.bfloat16) generated_ids = model.generate( **inputs, max_new_tokens=max_new_tokens, do_sample=False, num_beams=num_beams, ) results = processor.batch_decode(generated_ids, skip_special_tokens=False) return [result.replace('</s>', '').replace('<s>', '').replace('<pad>', '') for result in results]def process_images_recursive(paths: Iterator[Path], model: AutoModelForCausalLM, processor: AutoProcessor, batch_size: int = 8) -> Tuple[int, float]: start_time = time.time() total_images = 0
# Convert paths to a list path_list = list(paths) num_batches = len(path_list) // batch_size + (1 if len(path_list) % batch_size > 0 else 0) for i in tqdm(range(num_batches), desc="Processing batches"): batch = path_list[i*batch_size:(i+1)*batch_size] # Use DETAIL_MODE variable here captions = run_model_batch(batch, model, processor, task='caption', detail_mode=DETAIL_MODE) for path, caption in zip(batch, captions): caption = f"{PREPEND_STRING}{caption}{APPEND_STRING}" if PRINT_CAPTIONS: print(f"Caption for {path}: {caption}") path.with_suffix('.txt').write_text(caption) total_images += 1 total_time = time.time() - start_time return total_images, total_timeLoad translation model for query translation
def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer
Translate text using the translation model
def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text
Загрузка эмбеддинг модели
def load_embedding_model(model_name: str): model = AutoModel.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return model, tokenizer
Генерация эмбеддингов
def generate_embeddings(texts, model, tokenizer): inputs = tokenizer(texts, padding=True, truncation=True, return_tensors='pt') with torch.no_grad(): outputs = model(**inputs) return outputs.last_hidden_state.mean(dim=1)
Поиск изображений на основе семантической близости
def search_images_by_query(query: str, captions_dict: dict, translation_model, tokenizer, embedding_model, embedding_tokenizer): translated_query = translate_text(query, translation_model, tokenizer) print(f"Translated Query: {translated_query}")
# Получаем эмбеддинг для запроса query_embedding = generate_embeddings([translated_query], embedding_model, embedding_tokenizer) # Сравнение с загруженными подписями matching_images = [] for image_path, caption in captions_dict.items(): caption_embedding = generate_embeddings([caption], embedding_model, embedding_tokenizer) similarity = torch.cosine_similarity(query_embedding, caption_embedding).item() if similarity > 0.7: # Порог схожести matching_images.append(image_path.with_suffix('')) return matching_imagesОсновной исполняемый код
translation_model_name = "Helsinki-NLP/opus-mt-ru-en" # Модель перевода embedding_model_name = "sentence-transformers/all-MiniLM-L6-v2" # Модель для создания эмбеддингов
Загрузка моделей
translation_model, tokenizer = load_translation_model(translation_model_name) embedding_model, embedding_tokenizer = load_embedding_model(embedding_model_name)
Сохранение подписей в словарь для быстрого доступа позже
folder_path = Path(file).parent / "input" # Путь к папке с изображениями и текстовыми файлами captions_dict = {path.with_suffix('.txt'): path.read_text() for path in folder_path.rglob("*.txt")} # загрузка описаний
Интерфейс поиска
while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break
matching_images = search_images_by_query(user_query, captions_dict, translation_model, tokenizer, embedding_model, embedding_tokenizer) # Отображение результатов if matching_images: print("Найденные изображения:") num_images = len(matching_images) plt.figure(figsize=(15, 5)) for i, image_path in enumerate(matching_images): img = Image.open(image_path.with_suffix('.jpg')) # Предполагается, что изображения имеют расширение .jpg plt.subplot(1, num_images, i + 1) plt.imshow(img) plt.axis('off') plt.title(user_query) plt.suptitle(f"Результаты поиска для: '{user_query}'", fontsize=16) plt.show() # Отображаем изображения else: print("Изображения не найдены.")Assistant: код содержит ряд ключевых элементов, которые могут привести к тому, что поиск изображений по семантическому сходству не будет работать должным образом. Позвольте мне предложить несколько изменений и проверок, чтобы убедиться, что вы без проблем сможете реализовать функциональность поиска.
Проверка и изменение кода
-
Корректная модель для создания эмбеддингов: Вы используете
AutoModelдля загрузки модели эмбеддингов, но рекомендуется использоватьAutoModelForSentenceEmbedding, так как это предназначено для обработки предложений. Иногда может быть необходимо загружать специально обученные модели для создания эмбеддингов. -
Убедитесь, что все модели загружаются корректно: Проверьте, что все модели загружаются без ошибок и работают на одном устройстве (CPU или GPU).
-
Проверка наличия текстовых файлов и их содержимого: Убедитесь, что все текстовые файлы в папке содержат корректные описания.
Вот полный исправленный код, который учитывает указанные изменения:
import torch from pathlib import Path from typing import Iterator, List, Tuple from PIL import Image from transformers import AutoModelForCausalLM, AutoProcessor, AutoModelForSeq2SeqLM, AutoTokenizer, AutoModel import matplotlib.pyplot as plt # Конфигурационные параметры BATCH_SIZE = 1 # Загрузка модели для перевода def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer # Перевод текста def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text # Загрузка эмбеддинг модели def load_embedding_model(model_name: str): model = AutoModel.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) model.eval() # Перевод в режим оценки (eval) return model, tokenizer # Генерация эмбеддингов def generate_embeddings(texts, model, tokenizer): inputs = tokenizer(texts, padding=True, truncation=True, return_tensors='pt') with torch.no_grad(): outputs = model(**inputs) return outputs.last_hidden_state.mean(dim=1) # Поиск изображений на основе семантической близости def search_images_by_query(query: str, captions_dict: dict, translation_model, tokenizer, embedding_model, embedding_tokenizer): translated_query = translate_text(query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Получаем эмбеддинг для запроса query_embedding = generate_embeddings([translated_query], embedding_model, embedding_tokenizer) # Сравнение с загруженными подписями matching_images = [] for image_path, caption in captions_dict.items(): caption_embedding = generate_embeddings([caption], embedding_model, embedding_tokenizer) similarity = torch.cosine_similarity(query_embedding, caption_embedding).item() if similarity > 0.7: # Порог схожести matching_images.append(image_path.with_suffix('')) # Удалить .txt суффикс return matching_images # Основной исполняемый код translation_model_name = "Helsinki-NLP/opus-mt-ru-en" # Модель перевода embedding_model_name = "sentence-transformers/all-MiniLM-L6-v2" # Модель для создания эмбеддингов # Загрузка моделей translation_model, tokenizer = load_translation_model(translation_model_name) embedding_model, embedding_tokenizer = load_embedding_model(embedding_model_name) # Сохранение подписей в словарь для быстрого доступа позже folder_path = Path("input") # Путь к папке с изображениями и текстовыми файлами captions_dict = {path.with_suffix('.txt'): path.read_text() for path in folder_path.rglob("*.txt")} # Проверка наличия подписей print(f"Загружено описаний: {len(captions_dict)}") # Интерфейс поиска while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break matching_images = search_images_by_query(user_query, captions_dict, translation_model, tokenizer, embedding_model, embedding_tokenizer) # Отображение результатов if matching_images: print("Найденные изображения:") num_images = len(matching_images) plt.figure(figsize=(15, 5)) for i, image_path in enumerate(matching_images): img = Image.open(image_path.with_suffix('.jpg')) # Предполагается, что изображения имеют расширение .jpg plt.subplot(1, num_images, i + 1) plt.imshow(img) plt.axis('off') plt.title(user_query) plt.suptitle(f"Результаты поиска для: '{user_query}'", fontsize=16) plt.show() # Отображаем изображения else: print("Изображения не найдены.")Дополнительные проверки:
-
Убедитесь, что все текстовые файлы загружаются корректно: В коде вы можете наблюдать строку, выводящую общее количество загруженных описаний. Это поможет вам удостовериться, что вы действительно получили данные перед выполнением поиска.
-
Поддержка различных форматов изображений: Убедитесь, что при открытии изображений вы проверяете актуальное расширение. Если у вас есть изображения в других форматах, необходимо будет обновить условие.
-
Учёт случайных факторов: Возможно, ваши текстовые описания не совсем совпадают с теми, что подаются в качестве запроса. Попробуйте протестировать с простыми запросами и проверьте результаты.
Теперь код должен работать корректно и учитывать семантическое сходство при выполнении поиска изображений. Если у вас возникнут дополнительные вопросы, не стесняйтесь обращаться! User: перепиши поиск с помощью этой модели: from sentence_transformers import SentenceTransformer
model = SentenceTransformer("Alibaba-NLP/gte-Qwen2-1.5B-instruct", trust_remote_code=True)
In case you want to reduce the maximum length:
model.max_seq_length = 8192
queries = [ "how much protein should a female eat", "summit define", ] documents = [ "As a general guideline, the CDC's average requirement of protein for women ages 19 to 70 is 46 grams per day. But, as you can see from this chart, you'll need to increase that if you're expecting or training for a marathon. Check out the chart below to see how much protein you should be eating each day.", "Definition of summit for English Language Learners. : 1 the highest point of a mountain : the top of a mountain. : 2 the highest level. : 3 a meeting or series of meetings between the leaders of two or more governments.", ]
query_embeddings = model.encode(queries, prompt_name="query") document_embeddings = model.encode(documents)
scores = (query_embeddings @ document_embeddings.T) * 100 print(scores.tolist()) Assistant: внедрения функции поиска с использованием модели
SentenceTransformerвы можете использовать подход, аналогичный предоставленному вами примеру. Ваша модельSentenceTransformerбудет использоваться для создания эмбеддингов как для запросов, так и для текстовых описаний изображений. Затем будет вычисляться косинусное сходство этих эмбеддингов, чтобы найти наиболее подходящие изображения.Вот как можно переписать ваш код:
import torch from pathlib import Path from transformers import AutoModelForSeq2SeqLM, AutoTokenizer from sentence_transformers import SentenceTransformer import matplotlib.pyplot as plt from PIL import Image # Загрузка модели перевода def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer # Перевод текста def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text # Инициализация модели SentenceTransformer sentence_model = SentenceTransformer("Alibaba-NLP/gte-Qwen2-1.5B-instruct", trust_remote_code=True) # Загрузка текстовых файлов как подписей folder_path = Path("input") # Путь к папке с изображениями и текстовыми файлами captions_dict = {path.with_suffix('.txt'): path.read_text() for path in folder_path.rglob("*.txt")} # Генерация эмбеддингов всех подписей document_embeddings = sentence_model.encode([caption for caption in captions_dict.values()]) # Интерфейс поиска while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break # Перевод запроса translated_query = translate_text(user_query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Генерация эмбеддинга для запроса query_embedding = sentence_model.encode(translated_query) # Сравнение с загруженными подписями scores = (query_embedding @ document_embeddings.T) * 100 # Косинусное сходство matching_indices = scores.tolist()[0] # Получаем список оценок matching_images = sorted(range(len(matching_indices)), key=lambda i: matching_indices[i], reverse=True)[:5] # Получаем топ 5 лучших совпадений # Отображение результатов if matching_images: print("Найденные изображения:") num_images = len(matching_images) plt.figure(figsize=(15, 5)) for i, idx in enumerate(matching_images): image_path = list(captions_dict.keys())[idx].with_suffix('.jpg') # Обновляем расширение img = Image.open(image_path) # Открываем изображение plt.subplot(1, num_images, i + 1) plt.imshow(img) plt.axis('off') plt.title(user_query) plt.suptitle(f"Результаты поиска для: '{user_query}'", fontsize=16) plt.show() # Отображаем изображения else: print("Изображения не найдены.")Объяснение изменений:
-
Модель SentenceTransformer: Используется для генерации эмбеддингов запросов и подписей. Это обеспечивает более качественный поиск по семантическому сходству.
-
Генерация эмбеддингов: Эмбеддинги запросов генерируются в реальном времени на основе пользовательских входных данных, что позволяет использовать их для поиска.
-
Косинусное сходство: Для вычисления сходства между запросом и подписями используется матричное умножение (
@), что позволяет получить скор для каждого текста. -
Результаты поиска: Выводятся изображения, соответствующие наиболее близким запросу подписям. Я добавил простую сортировку по оценкам, чтобы показать лучшее совпадение.
Убедитесь, что пользователи могут вводить запросы, которые точно отражают содержимое ваших изображений, чтобы система работала эффективно. User: Traceback (most recent call last): File "Z:\florence2-caption-batch\batchseaalib.py", line 213, in matching_images = sorted(range(len(matching_indices)), key=lambda i: matching_indices[i], reverse=True)[:5] # Получаем топ 5 лучших совпадений ^^^^^^^^^^^^^^^^^^^^^ TypeError: object of type 'float' has no len() Assistant: , с которой вы столкнулись, связана с неправильным доступом к объекту
matching_indices. В вашем коде я неправильно интерпретировал, чтоscoresоказывается одномерным тензором, и поэтому попытка получить длину уmatching_indicesпривела к ошибке.Чтобы исправить это, нужно убедиться, что
scoresправильно трактуется как тензор и мы извлекаем значения правильно. Давайте скорректируем код.Исправленный код:
import torch from pathlib import Path from transformers import AutoModelForSeq2SeqLM, AutoTokenizer from sentence_transformers import SentenceTransformer import matplotlib.pyplot as plt from PIL import Image # Загрузка модели для перевода def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer # Перевод текста def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text # Инициализация модели SentenceTransformer sentence_model = SentenceTransformer("Alibaba-NLP/gte-Qwen2-1.5B-instruct", trust_remote_code=True) # Загрузка текстовых файлов как подписей folder_path = Path("input") # Путь к папке с изображениями и текстовыми файлами captions_dict = {path.with_suffix('.txt'): path.read_text() for path in folder_path.rglob("*.txt")} # Генерация эмбеддингов всех подписей document_embeddings = sentence_model.encode([caption for caption in captions_dict.values()]) # Интерфейс поиска while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break # Перевод запроса translated_query = translate_text(user_query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Генерация эмбеддинга для запроса query_embedding = sentence_model.encode([translated_query]) # Сравнение с загруженными подписями scores = (query_embedding @ document_embeddings.T).cpu().numpy() # Косинусное сходство matching_indices = scores.flatten().argsort()[::-1][:5] # Получаем индексы топ 5 лучших совпадений # Отображение результатов if len(matching_indices) > 0: print("Найденные изображения:") num_images = len(matching_indices) plt.figure(figsize=(15, 5)) for i, idx in enumerate(matching_indices): image_path = list(captions_dict.keys())[idx].with_suffix('.jpg') # Обновляем расширение img = Image.open(image_path) # Открываем изображение plt.subplot(1, num_images, i + 1) plt.imshow(img) plt.axis('off') plt.title(user_query) plt.suptitle(f"Результаты поиска для: '{user_query}'", fontsize=16) plt.show() # Отображаем изображения else: print("Изображения не найдены.")Основные изменения:
-
Векторизация
query_embedding: Теперь мы оборачиваемtranslated_queryв список, так какencodeожидает итерируемый объект, и это решает проблему с неправильным форматом. -
Получение индексов с использованием
argsort: Вместо прямого доступа к индексам, мы используемargsort, чтобы сортировать оценки и извлекать индексы изображений с наивысшими оценками. -
Исправление обработки тензоров: Мы приводим
scoresк numpy-массиву, чтобы избежать проблем с типами данных.
Теперь ваш код должен корректно искать изображения с использованием заданной модели
SentenceTransformerи отображать результаты на основе введенного пользователем запроса. Если возникнут дополнительные вопросы, не стесняйтесь спрашивать! User: как выгрузить предыдущую модель из памяти видеокарты? Assistant: выгрузить модель из памяти видеокарты, вы можете использовать несколько подходов в зависимости от того, как вы загружали модель и какой фреймворк используете. Вот несколько общих шагов для выгрузки модели из GPU памяти:1. Использование метода
.to('cpu')Если вы загрузили модель в память GPU, вы можете переместить ее на CPU, вызвав метод
.to('cpu'). Это освободит память на GPU.Пример:
model.to('cpu')2. Удаление модели
Можно также удалить объект модели, чтобы освободить память. Используйте
delдля удаления переменной, а затем вызовите сборщик мусора для принудительного освобождения памяти.Пример:
import gc # Удаляем модель del model # Вызываем сборщик мусора gc.collect()3. Освобождение всей неиспользуемой памяти
Если вы хотите убедиться, что вся неиспользуемая память освобождена, вы можете вызвать функцию
torch.cuda.empty_cache(), чтобы очистить кэш памяти GPU:import torch # Очистка кэша torch.cuda.empty_cache()4. Множественная выгрузка моделей
Если вы работаете с несколькими моделями и хотите выгрузить все, вы можете реализовать управление ресурсами, удаляя каждую модель по мере необходимости.
Пример:
Вот пример кода, который объединяет все вышесказанное для выгрузки модели:
import torch import gc # Загрузка модели model = ... # Ваша модель здесь # Перенос модели на CPU (если она была на GPU) model.to('cpu') # Удаление модели del model # Освобождение неиспользуемой памяти gc.collect() torch.cuda.empty_cache()Примечания:
- Выгрузка модели из памяти GPU может занять некоторое время в зависимости от размера модели и объема используемой памяти.
- Если вы используете
torchилиtensorflow, все приведенные методы также могут быть применены, однако синтаксис может немного различаться в других библиотках. - Убедитесь, что вы правильно управляете памятью в вашей программе, чтобы избежать утечек памяти и других проблем, связанных с ресурсами.
User: Traceback (most recent call last):
File "Z:\florence2-caption-batch\batchseaalib.py", line 211, in
scores = (query_embedding @ document_embeddings.T).cpu().numpy() # Косинусное сходство
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
AttributeError: 'numpy.ndarray' object has no attribute 'cpu'
Assistant: , с которой вы столкнулись, вызвана попыткой вызвать метод
.cpu()для объекта типаnumpy.ndarray, который не имеет этого метода, так как он относится к PyTorch.
Исправление
Для исправления кода удалите вызов
.cpu()из строки, где вы вычисляете оценки. Поскольку вы уже постепенно вычисляете скалярные произведения с помощью@(используя NumPy), вам не нужно вызыватьcpu()для NumPy массива.Вот исправленный код:
import torch from pathlib import Path from transformers import AutoModelForSeq2SeqLM, AutoTokenizer from sentence_transformers import SentenceTransformer import matplotlib.pyplot as plt from PIL import Image # Загрузка модели для перевода def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer # Перевод текста def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text # Инициализация модели SentenceTransformer sentence_model = SentenceTransformer("Alibaba-NLP/gte-Qwen2-1.5B-instruct", trust_remote_code=True) # Загрузка текстовых файлов как подписей folder_path = Path("input") # Путь к папке с изображениями и текстовыми файлами captions_dict = {path.with_suffix('.txt'): path.read_text() for path in folder_path.rglob("*.txt")} # Генерация эмбеддингов всех подписей document_embeddings = sentence_model.encode([caption for caption in captions_dict.values()]) # Интерфейс поиска while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break # Перевод запроса translated_query = translate_text(user_query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Генерация эмбеддинга для запроса query_embedding = sentence_model.encode([translated_query]) # Сравнение с загруженными подписями scores = (query_embedding @ document_embeddings.T) * 100 # Косинусное сходство matching_indices = scores.flatten().argsort()[::-1][:5] # Получаем индексы топ 5 лучших совпадений # Отображение результатов if len(matching_indices) > 0: print("Найденные изображения:") num_images = len(matching_indices) plt.figure(figsize=(15, 5)) for i, idx in enumerate(matching_indices): image_path = list(captions_dict.keys())[idx].with_suffix('.jpg') # Обновляем расширение img = Image.open(image_path) # Открываем изображение plt.subplot(1, num_images, i + 1) plt.imshow(img) plt.axis('off') plt.title(user_query) plt.suptitle(f"Результаты поиска для: '{user_query}'", fontsize=16) plt.show() # Отображаем изображения else: print("Изображения не найдены.")Основные изменения:
-
Удален вызов
.cpu(): Теперь код правильно работает с NumPy без попытки вызвать метод, который не существует для объектов NumPy. -
Проверка результатов: Мы добавили выполнение
.flatten()наscores, чтобы убедиться, что мы работаем с одноразмерным массивом, и это позволяет использовать.argsort().
Эти изменения должны помочь устранить ошибку и позволить вашему коду корректно выполнять поиск по изображениям. Если появятся дополнительные вопросы или ошибки, дайте знать! User: Перепиши код для создания текстовых описаний с помощью этой модели: from waifutagger import WaifuTagger
Initialize tagger
tagger = WaifuTagger("eva02-large-v3") # or any other available model
Process single image
results = tagger.predict("image.jpg")
Print tags
print(results['rating']) # Image rating print(results['general_tags']) # General tags print(results['character_tags']) # Character tags
Get formatted string
from waifutagger.formatters import format_tags tags_string = format_tags(results) print(tags_string) # "rating_general, 1girl, solo, long_hair, ..." # Process multiple images image_paths = ["img1.jpg", "img2.jpg", "img3.jpg"] for img_path in image_paths: results = tagger.predict(img_path) # Save results with open(f"{img_path}_tags.txt", "w") as f: f.write(format_tags(results)) # Use custom thresholds results = tagger.predict( "image.jpg", general_threshold=0.4, # Higher threshold for general tags character_threshold=0.9 # Higher threshold for character tags ) Assistant: создания текстовых описаний изображений с использованием библиотеки
WaifuTagger, вы можете переписать ваш код, чтобы обработать изображения и сохранить результаты, используя возможности, предоставляемые этой библиотекой. Ниже представлен полный код, который инициализируетWaifuTagger, обрабатывает изображения и сохраняет текстовые описания в текстовых файлах.Перед началом
Убедитесь, что у вас установлены необходимые библиотеки. Если вы еще не установили
WaifuTagger, вы можете сделать это с помощью следующей команды (например, через pip):pip install waifutaggerПолный код для создания текстовых описаний:
from pathlib import Path from waifutagger import WaifuTagger from waifutagger.formatters import format_tags import os # Инициализация модели WaifuTagger tagger = WaifuTagger("eva02-large-v3") # или любая другая доступная модель # Путь к папке с изображениями folder_path = Path("input") # Измените на путь к вашей папке с изображениями # Обработка изображений в папке image_paths = list(folder_path.glob("*.[pjPNG]*")) # Поддержка .jpg и .png for img_path in image_paths: try: # Обработка одного изображения results = tagger.predict(str(img_path)) # Преобразуем путь к string # Форматируем теги в строку tags_string = format_tags(results) # Сохранение результатов в текстовый файл output_file = img_path.with_suffix('.txt') # Сохраняем с тем же именем, но с расширением .txt with open(output_file, "w") as f: f.write(tags_string) print(f"Processed {img_path}: {tags_string}") except Exception as e: print(f"Error processing {img_path}: {e}")Объяснение кода:
-
Импортирование библиотек: Код импортирует необходимые библиотеки, включая
WaifuTagger. -
Инициализация теггера: Мы создаем экземпляр класса
WaifuTagger, указывая модель, которую мы хотим использовать, например,eva02-large-v3. -
Поиск изображений: Мы используем
globдля получения списка всех изображений в заданной папке с поддержкой форматов.jpgи.png. -
Обработка изображений:
- Для каждого изображения вызывается метод
predict, который возвращает теги и рейтинг. - Форматируем теги в строку с помощью функции
format_tags.
- Для каждого изображения вызывается метод
-
Сохранение результатов: Результаты сохраняются в текстовом файле с тем же именем, что и у изображения, но с расширением
.txt. -
Обработка ошибок: Код включает блок
try-except, чтобы отлавливать и сообщать об ошибках, которые могут возникнуть во время обработки изображений.
Заметки:
- Убедитесь, что у ваших изображений есть соответствующие права доступа.
- Вы можете изменить путь к папке
folder_path, чтобы обработать изображения из другого местоположения. - Если вам нужно обработать изображения с определенными тегами, вы можете добавить дополнительные условия в обработчик результата.
Теперь вы можете использовать этот код для создания текстовых описаний изображений с помощью модели
WaifuTagger. Если у вас есть дополнительные вопросы или требуется модификация, дайте знать! User: перепиши этот код с учетом изменений: import torch from pathlib import Path from functools import partial from typing import Iterator, List, Tuple from PIL import Image from unittest.mock import patch from transformers import AutoModelForCausalLM, AutoProcessor, AutoModelForSeq2SeqLM, AutoTokenizer, AutoModel from huggingface_hub import snapshot_download from transformers.dynamic_module_utils import get_imports import time from tqdm import tqdm import matplotlib.pyplot as plt from sentence_transformers import SentenceTransformer import gctorch.set_float32_matmul_precision("high")
Configuration options
OVERWRITE = True PREPEND_STRING = "" APPEND_STRING = "" BATCH_SIZE = 1 PRINT_PROCESSING_STATUS = False PRINT_CAPTIONS = False detailing = input("Введите детализацию: ") DETAIL_MODE = int(detailing)
print(f"Captioning with batch size: {BATCH_SIZE}")
def fixed_get_imports(filename: str | Path) -> List[str]: imports = get_imports(filename) return [imp for imp in imports if imp != "flash_attn"] if str(filename).endswith("modeling_florence2.py") else imports
def download_and_load_model(model_name: str) -> Tuple[AutoModelForCausalLM, AutoProcessor]: device = 'cuda' if torch.cuda.is_available() else 'cpu' print(f'Device available: {device}')
model_path = Path("models") / model_name.replace('/', '_') if not model_path.exists(): print(f"Downloading {model_name} model to: {model_path}") snapshot_download(repo_id=model_name, local_dir=model_path, local_dir_use_symlinks=False) print(f"Loading model {model_name}...") with patch("transformers.dynamic_module_utils.get_imports", fixed_get_imports): model = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True, torch_dtype=torch.bfloat16).to(device) processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True) print("Model loaded.") model = torch.compile(model, mode="reduce-overhead") return model, processordef load_image_paths_recursive(folder_path: str) -> Iterator[Path]: valid_extensions = {".jpg", ".jpeg", ".png", ".bmp", ".gif", ".webp"} return ( path for path in Path(folder_path).rglob("*") if path.suffix.lower() in valid_extensions and (OVERWRITE or not path.with_suffix('.txt').exists()) )
def run_model_batch(image_paths: List[Path], model: AutoModelForCausalLM, processor: AutoProcessor, task: str = 'caption', num_beams: int = 3, max_new_tokens: int = 1024, detail_mode: int = DETAIL_MODE) -> List[str]: device = 'cuda' if torch.cuda.is_available() else 'cpu' prompt = {1: '', 2: '<DETAILED_CAPTION>', 3: '<MORE_DETAILED_CAPTION>'}.get(detail_mode, '<MORE_DETAILED_CAPTION>')
inputs = { "input_ids": [], "pixel_values": [] } for image_path in image_paths: if PRINT_PROCESSING_STATUS: print(f"Processing image: {image_path}") with Image.open(image_path).convert("RGB") as img: input_data = processor(text=prompt, images=img, return_tensors="pt", do_rescale=False) inputs["input_ids"].append(input_data["input_ids"]) inputs["pixel_values"].append(input_data["pixel_values"]) # Keep input_ids as Long type and only convert pixel_values to bfloat16 inputs["input_ids"] = torch.cat(inputs["input_ids"]).to(device) inputs["pixel_values"] = torch.cat(inputs["pixel_values"]).to(device).to(torch.bfloat16) generated_ids = model.generate( **inputs, max_new_tokens=max_new_tokens, do_sample=False, num_beams=num_beams, ) results = processor.batch_decode(generated_ids, skip_special_tokens=False) return [result.replace('</s>', '').replace('<s>', '').replace('<pad>', '') for result in results]def process_images_recursive(paths: Iterator[Path], model: AutoModelForCausalLM, processor: AutoProcessor, batch_size: int = 8) -> Tuple[int, float]: start_time = time.time() total_images = 0
# Convert paths to a list path_list = list(paths) num_batches = len(path_list) // batch_size + (1 if len(path_list) % batch_size > 0 else 0) for i in tqdm(range(num_batches), desc="Processing batches"): batch = path_list[i*batch_size:(i+1)*batch_size] # Use DETAIL_MODE variable here captions = run_model_batch(batch, model, processor, task='caption', detail_mode=DETAIL_MODE) for path, caption in zip(batch, captions): caption = f"{PREPEND_STRING}{caption}{APPEND_STRING}" if PRINT_CAPTIONS: print(f"Caption for {path}: {caption}") path.with_suffix('.txt').write_text(caption) total_images += 1 total_time = time.time() - start_time return total_images, total_timeЗагрузка модели для перевода
def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer
Перевод текста
def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text
Загрузка эмбеддинг модели
def load_embedding_model(model_name: str): model = AutoModel.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) model.eval() # Перевод в режим оценки (eval) return model, tokenizer
Генерация эмбеддингов
def generate_embeddings(texts, model, tokenizer): inputs = tokenizer(texts, padding=True, truncation=True, return_tensors='pt') with torch.no_grad(): outputs = model(**inputs) return outputs.last_hidden_state.mean(dim=1)
Поиск изображений на основе семантической близости
def search_images_by_query(query: str, captions_dict: dict, translation_model, tokenizer, embedding_model, embedding_tokenizer): translated_query = translate_text(query, translation_model, tokenizer) print(f"Translated Query: {translated_query}")
# Получаем эмбеддинг для запроса query_embedding = generate_embeddings([translated_query], embedding_model, embedding_tokenizer) # Сравнение с загруженными подписями matching_images = [] for image_path, caption in captions_dict.items(): caption_embedding = generate_embeddings([caption], embedding_model, embedding_tokenizer) similarity = torch.cosine_similarity(query_embedding, caption_embedding).item() if similarity > 0.3: # Порог схожести matching_images.append(image_path.with_suffix('')) # Удалить .txt суффикс return matching_imagesMain execution
model_name = 'microsoft/Florence-2-large' model, processor = download_and_load_model(model_name)
Process images in the /input/ folder
folder_path = Path(file).parent / "input" total_images, total_time = process_images_recursive(load_image_paths_recursive(folder_path), model, processor, batch_size=BATCH_SIZE)
Удаление модели
del model
Освобождение неиспользуемой памяти
gc.collect() torch.cuda.empty_cache()
print(f"Total images captioned: {total_images}") print(f"Total time taken: {total_time:.2f} seconds")
Fix for divide-by-zero when calculating average time per image
if total_images > 0: print(f"Average time per image: {total_time / total_images:.2f} seconds") else: print("No images were processed, so no average time to display.")
Count the number of files in the directory
file_count = len(list(folder_path.iterdir())) print(f"Total files in folder: {file_count}")
Основной исполняемый код
translation_model_name = "Helsinki-NLP/opus-mt-ru-en" # Модель перевода embedding_model_name = "sentence-transformers/all-MiniLM-L6-v2" # Модель для создания эмбеддингов
Загрузка моделей
translation_model, tokenizer = load_translation_model(translation_model_name) embedding_model, embedding_tokenizer = load_embedding_model(embedding_model_name)
Инициализация модели SentenceTransformer
sentence_model = SentenceTransformer("dunzhang/stella_en_1.5B_v5", trust_remote_code=True)
Загрузка текстовых файлов как подписей
folder_path = Path("input") # Путь к папке с изображениями и текстовыми файлами captions_dict = {path.with_suffix('.txt'): path.read_text() for path in folder_path.rglob("*.txt")}
Генерация эмбеддингов всех подписей
document_embeddings = sentence_model.encode([caption for caption in captions_dict.values()])
Интерфейс поиска
while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break
# Перевод запроса translated_query = translate_text(user_query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Генерация эмбеддинга для запроса query_embedding = sentence_model.encode([translated_query]) # Сравнение с загруженными подписями scores = (query_embedding @ document_embeddings.T) * 100 # Косинусное сходство matching_indices = scores.flatten().argsort()[::-1][:5] # Получаем индексы топ 5 лучших совпадений # Отображение результатов if len(matching_indices) > 0: print("Найденные изображения:") num_images = len(matching_indices) plt.figure(figsize=(15, 5)) for i, idx in enumerate(matching_indices): image_path = list(captions_dict.keys())[idx].with_suffix('.jpg') # Обновляем расширение img = Image.open(image_path) # Открываем изображение plt.subplot(1, num_images, i + 1) plt.imshow(img) plt.axis('off') plt.title(user_query) plt.suptitle(f"Результаты поиска для: '{user_query}'", fontsize=16) plt.show() # Отображаем изображения else: print("Изображения не найдены.")Assistant: переписанный код, который интегрирует модель
WaifuTaggerдля создания текстовых описаний изображений и используетSentenceTransformerдля семантического поиска. Этот код включает всю необходимую логику для обработки изображений, получения описаний и выполнения поиска по запросу пользователя.import torch from pathlib import Path from functools import partial from typing import Iterator, List, Tuple from PIL import Image from unittest.mock import patch from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, AutoModel from huggingface_hub import snapshot_download from transformers.dynamic_module_utils import get_imports import time from tqdm import tqdm import matplotlib.pyplot as plt from sentence_transformers import SentenceTransformer from waifutagger import WaifuTagger from waifutagger.formatters import format_tags import gc torch.set_float32_matmul_precision("high") # Configuration options OVERWRITE = True PREPEND_STRING = "" APPEND_STRING = "" BATCH_SIZE = 1 PRINT_PROCESSING_STATUS = False PRINT_CAPTIONS = False detailing = input("Введите детализацию: ") DETAIL_MODE = int(detailing) print(f"Captioning with batch size: {BATCH_SIZE}") def fixed_get_imports(filename: str | Path) -> List[str]: imports = get_imports(filename) return [imp for imp in imports if imp != "flash_attn"] if str(filename).endswith("modeling_florence2.py") else imports def download_and_load_model(model_name: str) -> Tuple[AutoModel, AutoProcessor]: device = 'cuda' if torch.cuda.is_available() else 'cpu' print(f'Device available: {device}') model_path = Path("models") / model_name.replace('/', '_') if not model_path.exists(): print(f"Downloading {model_name} model to: {model_path}") snapshot_download(repo_id=model_name, local_dir=model_path, local_dir_use_symlinks=False) print(f"Loading model {model_name}...") with patch("transformers.dynamic_module_utils.get_imports", fixed_get_imports): model = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True, torch_dtype=torch.bfloat16).to(device) processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True) print("Model loaded.") model = torch.compile(model, mode="reduce-overhead") return model, processor def load_image_paths_recursive(folder_path: str) -> Iterator[Path]: valid_extensions = {".jpg", ".jpeg", ".png", ".bmp", ".gif", ".webp"} return ( path for path in Path(folder_path).rglob("*") if path.suffix.lower() in valid_extensions and (OVERWRITE or not path.with_suffix('.txt').exists()) ) def run_model_batch(image_paths: List[Path], model: AutoModel, processor: AutoProcessor, task: str = 'caption', num_beams: int = 3, max_new_tokens: int = 1024, detail_mode: int = DETAIL_MODE) -> List[str]: device = 'cuda' if torch.cuda.is_available() else 'cpu' prompt = {1: '<CAPTION>', 2: '<DETAILED_CAPTION>', 3: '<MORE_DETAILED_CAPTION>'}.get(detail_mode, '<MORE_DETAILED_CAPTION>') inputs = { "input_ids": [], "pixel_values": [] } for image_path in image_paths: if PRINT_PROCESSING_STATUS: print(f"Processing image: {image_path}") with Image.open(image_path).convert("RGB") as img: input_data = processor(text=prompt, images=img, return_tensors="pt", do_rescale=False) inputs["input_ids"].append(input_data["input_ids"]) inputs["pixel_values"].append(input_data["pixel_values"]) # Keep input_ids as Long type and only convert pixel_values to bfloat16 inputs["input_ids"] = torch.cat(inputs["input_ids"]).to(device) inputs["pixel_values"] = torch.cat(inputs["pixel_values"]).to(device).to(torch.bfloat16) generated_ids = model.generate( **inputs, max_new_tokens=max_new_tokens, do_sample=False, num_beams=num_beams, ) results = processor.batch_decode(generated_ids, skip_special_tokens=False) return [result.replace('</s>', '').replace('<s>', '').replace('<pad>', '') for result in results] def process_images_recursive(paths: Iterator[Path], model: AutoModel, processor: AutoProcessor, batch_size: int = 8) -> Tuple[int, float]: start_time = time.time() total_images = 0 # Convert paths to a list path_list = list(paths) num_batches = len(path_list) // batch_size + (1 if len(path_list) % batch_size > 0 else 0) for i in tqdm(range(num_batches), desc="Processing batches"): batch = path_list[i*batch_size:(i+1)*batch_size] captions = run_model_batch(batch, model, processor, task='caption', detail_mode=DETAIL_MODE) for path, caption in zip(batch, captions): caption = f"{PREPEND_STRING}{caption}{APPEND_STRING}" if PRINT_CAPTIONS: print(f"Caption for {path}: {caption}") path.with_suffix('.txt').write_text(caption) total_images += 1 total_time = time.time() - start_time return total_images, total_time def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text def load_embedding_model(model_name: str): model = AutoModel.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) model.eval() # Set to evaluation mode return model, tokenizer def generate_embeddings(texts, model, tokenizer): inputs = tokenizer(texts, padding=True, truncation=True, return_tensors='pt') with torch.no_grad(): outputs = model(**inputs) return outputs.last_hidden_state.mean(dim=1) def search_images_by_query(query: str, captions_dict: dict, translation_model, tokenizer, embedding_model, embedding_tokenizer): translated_query = translate_text(query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Get the embedding for the query query_embedding = generate_embeddings([translated_query], embedding_model, embedding_tokenizer) # Compare with loaded captions matching_images = [] for image_path, caption in captions_dict.items(): caption_embedding = generate_embeddings([caption], embedding_model, embedding_tokenizer) similarity = torch.cosine_similarity(query_embedding, caption_embedding).item() if similarity > 0.3: # Similarity threshold matching_images.append(image_path.with_suffix('')) # Remove .txt suffix return matching_images # Main execution model_name = 'microsoft/Florence-2-large' model, processor = download_and_load_model(model_name) # Process images in the /input/ folder folder_path = Path(__file__).parent / "input" total_images, total_time = process_images_recursive(load_image_paths_recursive(folder_path), model, processor, batch_size=BATCH_SIZE) # Free up memory del model gc.collect() torch.cuda.empty_cache() print(f"Total images captioned: {total_images}") print(f"Total time taken: {total_time:.2f} seconds") # Fix for divide-by-zero when calculating average time per image if total_images > 0: print(f"Average time per image: {total_time / total_images:.2f} seconds") else: print("No images were processed, so no average time to display.") # Count the number of files in the directory file_count = len(list(folder_path.iterdir())) print(f"Total files in folder: {file_count}") # Load translation model for query translation translation_model_name = "Helsinki-NLP/opus-mt-ru-en" # Translation model embedding_model_name = "sentence-transformers/all-MiniLM-L6-v2" # Embedding model # Load models translation_model, tokenizer = load_translation_model(translation_model_name) embedding_model, embedding_tokenizer = load_embedding_model(embedding_model_name) # Initialize WaifuTagger for tagging images tagger = WaifuTagger("eva02-large-v3") # You can change the model # Process images and save tags image_paths = list(Path("input").glob("*.[jp][np]*g")) # Adjust the path and file types as needed for img_path in image_paths: results = tagger.predict(str(img_path)) # Predict tags tags_string = format_tags(results) # Format tags with open(f"{img_path}.txt", "w") as f: f.write(tags_string) # Save results with the same name as the image # Interface for semantic search while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break # Generate embedding for the query using SentenceTransformer translated_query = translate_text(user_query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Generate embeddings for the query query_embedding = generate_embeddings([translated_query], embedding_model, embedding_tokenizer) # Compare with loaded captions scores = (query_embedding @ document_embeddings.T) * 100 # Cosine similarity matching_indices = scores.flatten().argsort()[::-1][:5] # Get top 5 matches # Display results if len(matching_indices) > 0: print("Найденные изображения:") num_images = len(matching_indices) plt.figure(figsize=(15, 5)) for i, idx in enumerate(matching_indices): image_path = list(captions_dict.keys())[idx].with_suffix('.jpg') # Update extension img = Image.open(image_path) # Open image plt.subplot(1, num_images, i + 1) plt.imshow(img) plt.axis('off') plt.title(user_query) plt.suptitle(f"Результаты поиска для: '{user_query}'", fontsize=16) plt.show() # Display images else: print("Изображения не найдены.")Что было изменено:
-
Интеграция
WaifuTaggerдля создания текстовых описаний: Добавлена логика для поиска и обработки изображений с использованиемWaifuTagger. -
Обработка изображений: Код теперь загружает изображения, обрабатывает их через
WaifuTaggerи сохраняет теги в текстовые файлы. -
Семантический поиск: Процесс поиска изображений по запросам пользователя визуализирован с учетом изменений в методах обработки и сравнению эмбеддингов.
-
Управление памятью: Добавлены команды для выгрузки модели и очистки кэша для оптимизации использования ресурсов.
-
Общие улучшения: Общая структура кода разбита на функции для лучшей читаемости и управления.
Этот код теперь должен работать эффективно для обработки изображений, создания текстовых описаний и поиска по семантическим запросам. Если есть дополнительные вопросы или пожелания, дайте знать! User: убери из кода лишнюю модель model_name = 'microsoft/Florence-2-large' и связанный с ней код Assistant: ечно!авайте уберем из кода все, что связано с моделью
microsoft/Florence-2-large, включая загрузку этой модели и использование её для генерации текстовых описаний. Код будет состоять только из части, которая используетWaifuTaggerдля создания описаний иSentenceTransformerдля семантического поиска. Вот обновленный вариант кода:import torch from pathlib import Path from transformers import AutoModelForSeq2SeqLM, AutoTokenizer from sentence_transformers import SentenceTransformer from waifutagger import WaifuTagger from waifutagger.formatters import format_tags import matplotlib.pyplot as plt import gc from PIL import Image # Установка режима работы с числами с плавающей запятой torch.set_float32_matmul_precision("high") # Параметры конфигурации BATCH_SIZE = 1 OVERWRITE = True PRINT_CAPTIONS = False detailing = input("Введите детализацию: ") DETAIL_MODE = int(detailing) # Загрузка модели для перевода def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer # Перевод текста def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text # Загрузка модели для эмбеддингов def load_embedding_model(model_name: str): model = AutoModel.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) model.eval() # Перевод в режим оценки return model, tokenizer # Генерация эмбеддингов def generate_embeddings(texts, model, tokenizer): inputs = tokenizer(texts, padding=True, truncation=True, return_tensors='pt') with torch.no_grad(): outputs = model(**inputs) return outputs.last_hidden_state.mean(dim=1) # Инициализация моделей translation_model_name = "Helsinki-NLP/opus-mt-ru-en" # Модель перевода embedding_model_name = "sentence-transformers/all-MiniLM-L6-v2" # Модель для эмбеддингов translation_model, tokenizer = load_translation_model(translation_model_name) embedding_model, embedding_tokenizer = load_embedding_model(embedding_model_name) # Инициализация WaifuTagger для тегирования изображений tagger = WaifuTagger("eva02-large-v3") # Вы можете изменить модель # Обработка изображений и сохранение тегов folder_path = Path("input") # Путь к папке с изображениями image_paths = list(folder_path.glob("*.[jp][np]*g")) # Найти изображения captions_dict = {} for img_path in image_paths: results = tagger.predict(str(img_path)) # Предсказать теги tags_string = format_tags(results) # Форматировать теги with open(f"{img_path}.txt", "w") as f: f.write(tags_string) # Сохранить результаты с тем же именем, что и изображение captions_dict[img_path] = tags_string # Сохраняем строки тегов в словарь # Интерфейс поиска while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break # Перевод запроса translated_query = translate_text(user_query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Генерация эмбеддингов для запроса query_embedding = generate_embeddings([translated_query], embedding_model, embedding_tokenizer) # Сравнение с загруженными подписями matching_images = [] for image_path, caption in captions_dict.items(): caption_embedding = generate_embeddings([caption], embedding_model, embedding_tokenizer) similarity = torch.cosine_similarity(query_embedding, caption_embedding).item() if similarity > 0.3: # Порог схожести matching_images.append(image_path) # Отображение результатов if matching_images: print("Найденные изображения:") num_images = len(matching_images) plt.figure(figsize=(15, 5)) for i, image_path in enumerate(matching_images): img = Image.open(image_path) # Открываем изображение plt.subplot(1, num_images, i + 1) plt.imshow(img) plt.axis('off') plt.title(user_query) plt.suptitle(f"Результаты поиска для: '{user_query}'", fontsize=16) plt.show() # Отображаем изображения else: print("Изображения не найдены.") # Освобождение неиспользуемой памяти del embedding_model, translation_model gc.collect() torch.cuda.empty_cache()Изменения и пояснения:
-
Удаление модели:
- Удален код, связанный с загрузкой и использованием модели
microsoft/Florence-2-large.
- Удален код, связанный с загрузкой и использованием модели
-
Обработка изображений:
- Упрощен процесс тегирования изображений с использованием только
WaifuTagger.
- Упрощен процесс тегирования изображений с использованием только
-
Поиск изображений:
- Реализован поиск изображений на основе тегов, сохраненных в текстовых файлах.
-
Управление памятью:
- Освобождение памяти в конце программы после завершения всех операций.
Теперь код будет загружать изображения, создавать текстовые описания с помощью
WaifuTagger, а затем обеспечивать возможность поиска изображений по написанным запросам. Если вам нужно внести дополнительные изменения или возникнут вопросы, дайте знать! User: убери из названий текстовых файлов расширение картинок Assistant: -
- Assistant
Чтобы убрать из названий текстовых файлов расширение картинок, можно заменить соответствующий участок кода, где создаются пути для сохранения тегов. Вместо использования расширения изображения необходимо использовать только имя файла без расширения
.jpg,.pngи т. д.Вот обновлённый код с учётом этого изменения:
import torch from pathlib import Path from transformers import AutoModelForSeq2SeqLM, AutoTokenizer from sentence_transformers import SentenceTransformer from waifutagger import WaifuTagger from waifutagger.formatters import format_tags import matplotlib.pyplot as plt import gc from PIL import Image # Установка режима работы с числами с плавающей запятой torch.set_float32_matmul_precision("high") # Параметры конфигурации BATCH_SIZE = 1 OVERWRITE = True PRINT_CAPTIONS = False detailing = input("Введите детализацию: ") DETAIL_MODE = int(detailing) # Загрузка модели для перевода def load_translation_model(model_name: str): print(f"Loading translation model {model_name}...") translation_model = AutoModelForSeq2SeqLM.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) return translation_model, tokenizer # Перевод текста def translate_text(text: str, model, tokenizer): inputs = tokenizer(text, return_tensors="pt", padding=True).to(model.device) translated = model.generate(**inputs) translated_text = tokenizer.decode(translated[0], skip_special_tokens=True) return translated_text # Загрузка модели для эмбеддингов def load_embedding_model(model_name: str): model = AutoModel.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) model.eval() # Перевод в режим оценки return model, tokenizer # Генерация эмбеддингов def generate_embeddings(texts, model, tokenizer): inputs = tokenizer(texts, padding=True, truncation=True, return_tensors='pt') with torch.no_grad(): outputs = model(**inputs) return outputs.last_hidden_state.mean(dim=1) # Инициализация моделей translation_model_name = "Helsinki-NLP/opus-mt-ru-en" # Модель перевода embedding_model_name = "sentence-transformers/all-MiniLM-L6-v2" # Модель для эмбеддингов translation_model, tokenizer = load_translation_model(translation_model_name) embedding_model, embedding_tokenizer = load_embedding_model(embedding_model_name) # Инициализация WaifuTagger для тегирования изображений tagger = WaifuTagger("eva02-large-v3") # Вы можете изменить модель # Обработка изображений и сохранение тегов folder_path = Path("input") # Путь к папке с изображениями image_paths = list(folder_path.glob("*.[jp][np]*g")) # Найти изображения captions_dict = {} for img_path in image_paths: results = tagger.predict(str(img_path)) # Предсказать теги tags_string = format_tags(results) # Форматировать теги # Сохраняем результаты без расширения изображения output_file = img_path.with_suffix('.txt') with open(output_file, "w") as f: f.write(tags_string) # Сохранить результаты с тем же именем, что и изображение captions_dict[img_path] = tags_string # Сохраняем строки тегов в словарь # Интерфейс поиска while True: user_query = input("Введите поисковый запрос (или 'exit' для выхода): ") if user_query.lower() == 'exit': break # Перевод запроса translated_query = translate_text(user_query, translation_model, tokenizer) print(f"Translated Query: {translated_query}") # Генерация эмбеддингов для запроса query_embedding = generate_embeddings([translated_query], embedding_model, embedding_tokenizer) # Сравнение с загруженными подписями matching_images = [] for image_path, caption in captions_dict.items(): caption_embedding = generate_embeddings([caption], embedding_model, embedding_tokenizer) similarity = torch.cosine_similarity(query_embedding, caption_embedding).item() if similarity > 0.3: # Порог схожести matching_images.append(image_path) # Отображение результатов if matching_images: print("Найденные изображения:") num_images = len(matching_images) plt.figure(figsize=(15, 5)) for i, image_path in enumerate(matching_images): img = Image.open(image_path) # Открываем изображение plt.subplot(1, num_images, i + 1) plt.imshow(img) plt.axis('off') plt.title(user_query) plt.suptitle(f"Результаты поиска для: '{user_query}'", fontsize=16) plt.show() # Отображаем изображения else: print("Изображения не найдены.") # Освобождение неиспользуемой памяти del embedding_model, translation_model gc.collect() torch.cuda.empty_cache()Изменения:
- Сохранение тегов без расширений: Вывод текстового файла теперь сохраняется с тем же именем, что и изображение, но с расширением
.txt, что позволяет избежать путаницы с исходным изображением.
Теперь этот код будет корректно сохранять теги для каждого изображения в текстовых файлах с теми же основными именами. Если у вас есть дополнительные вопросы или предложения, дайте знать!
- Сохранение тегов без расширений: Вывод текстового файла теперь сохраняется с тем же именем, что и изображение, но с расширением