init

app.py

@@ -365,8 +365,9 @@ def audio_zero_shot_classifier(audio, candidate_labels, model_name):
                 # Загружаем модель для аудио эмбеддингов
                 audio_processor = AutoProcessor.from_pretrained(model_name)
                 audio_model = AutoModel.from_pretrained(model_name)
-                # Загружаем модель для текстовых эмбеддингов
-                text_model = SentenceTransformer('all-MiniLM-L6-v2')
+                # Загружаем модель для текстовых эмбеддингов с размерностью 768
+                # Используем модель с размерностью 768 для совместимости с Wav2Vec2
+                text_model = SentenceTransformer('all-mpnet-base-v2')
                 cached = (audio_processor, audio_model, text_model)
                 model_cache.put(cache_key, cached)
             
@@ -396,6 +397,23 @@ def audio_zero_shot_classifier(audio, candidate_labels, model_name):
             text_embeddings = text_model.encode(labels, convert_to_tensor=True)
             text_embeddings = text_embeddings / text_embeddings.norm(dim=1, keepdim=True)
             
+            # Проверяем размерности и проецируем если нужно
+            audio_dim = audio_embedding.shape[1]
+            text_dim = text_embeddings.shape[1]
+            
+            if audio_dim != text_dim:
+                # Если размерности не совпадают, проецируем меньший эмбеддинг в большее пространство
+                if audio_dim > text_dim:
+                    # Проецируем текстовые эмбеддинги в пространство аудио
+                    projection = torch.nn.Linear(text_dim, audio_dim).to(text_embeddings.device)
+                    text_embeddings = projection(text_embeddings)
+                    text_embeddings = text_embeddings / text_embeddings.norm(dim=1, keepdim=True)
+                else:
+                    # Проецируем аудио эмбеддинги в пространство текста
+                    projection = torch.nn.Linear(audio_dim, text_dim).to(audio_embedding.device)
+                    audio_embedding = projection(audio_embedding)
+                    audio_embedding = audio_embedding / audio_embedding.norm(dim=1, keepdim=True)
+            
             # Вычисляем косинусное сходство
             similarities = cosine_similarity(audio_embedding, text_embeddings).squeeze(0)
             # Применяем softmax для получения вероятностей
@@ -503,6 +521,24 @@ def speech_synthesis(text, model_name):
             
             # Для других моделей используем стандартный pipeline
             try:
+                # Проверяем, что текст не пустой
+                if not text or not text.strip():
+                    raise ValueError("Текст для синтеза не может быть пустым")
+                
+                # Для MMS TTS моделей проверяем язык
+                if "mms-tts" in model_name.lower():
+                    # MMS TTS модели обычно поддерживают только один язык
+                    # eng - английский, rus - русский и т.д.
+                    if "mms-tts-eng" in model_name.lower():
+                        # Проверяем, что текст на английском (простая проверка)
+                        # Если текст содержит кириллицу, это может быть проблемой
+                        has_cyrillic = any('\u0400' <= char <= '\u04FF' for char in text)
+                        if has_cyrillic:
+                            raise ValueError(
+                                f"Модель '{model_name}' поддерживает только английский язык. "
+                                f"Для русского текста используйте модель 'facebook/mms-tts-rus' или 'microsoft/speecht5_tts'."
+                            )
+                
                 tts = get_pipeline("text-to-speech", model_name)
                 result = tts(text)
             except Exception as e:
@@ -513,6 +549,12 @@ def speech_synthesis(text, model_name):
                         f"Эта модель может требовать другую библиотеку (например, Fairseq или ESPnet). "
                         f"Попробуйте использовать модель microsoft/speecht5_tts, которая полностью поддерживается."
                     ) from e
+                elif "negative output size" in error_msg.lower() or "input size 0" in error_msg.lower():
+                    raise ValueError(
+                        f"Ошибка обработки текста моделью '{model_name}'. "
+                        f"Возможные причины: неподдерживаемый язык, пустой текст после обработки, или проблема с токенизацией. "
+                        f"Попробуйте использовать другую модель или проверьте язык текста."
+                    ) from e
                 raise
             
             # Pipeline может возвращать словарь или кортеж
@@ -686,12 +728,16 @@ def image_segmentation(image, model_name):
         overlay = Image.new("RGBA", image.size, (0, 0, 0, 0))
         draw = ImageDraw.Draw(overlay)
         
+        # Список для хранения информации о сегментах (для добавления текста)
+        segments_info = []
+        
         for i, item in enumerate(result):
             label = item['label']
             score = item['score']
             
             # Генерируем полупрозрачный цвет для сегмента
             color = tuple(np.random.randint(0, 255, 3)) + (128,)  # RGBA с прозрачностью
+            color_rgb = color[:3]  # RGB цвет для текста
             
             # Проверяем наличие маски
             if 'mask' in item:
@@ -712,6 +758,38 @@ def image_segmentation(image, model_name):
                     else:
                         mask_array = mask_array.astype(np.uint8)
                 
+                # Находим центр маски для размещения текста
+                if len(mask_array.shape) == 2:  # Grayscale mask
+                    mask_bool = mask_array > 0
+                elif len(mask_array.shape) == 3 and mask_array.shape[2] == 1:
+                    mask_bool = mask_array[:, :, 0] > 0
+                else:
+                    if mask_array.shape[2] >= 1:
+                        mask_bool = mask_array[:, :, 0] > 0
+                    else:
+                        mask_bool = np.zeros(mask_array.shape[:2], dtype=bool)
+                
+                # Вычисляем центр маски
+                if np.any(mask_bool):
+                    y_coords, x_coords = np.where(mask_bool)
+                    if len(y_coords) > 0 and len(x_coords) > 0:
+                        center_y = int(np.mean(y_coords))
+                        center_x = int(np.mean(x_coords))
+                        
+                        # Масштабируем координаты, если маска другого размера
+                        if mask_array.shape[:2] != image.size[::-1]:
+                            scale_y = image.size[1] / mask_array.shape[0]
+                            scale_x = image.size[0] / mask_array.shape[1]
+                            center_y = int(center_y * scale_y)
+                            center_x = int(center_x * scale_x)
+                        
+                        segments_info.append({
+                            'label': label,
+                            'score': score,
+                            'center': (center_x, center_y),
+                            'color': color_rgb
+                        })
+                
                 # Создаем цветную маску
                 if len(mask_array.shape) == 2:  # Grayscale mask
                     # Создаем RGBA маску
@@ -751,6 +829,61 @@ def image_segmentation(image, model_name):
         if overlay.size == img_with_segments.size:
             img_with_segments = Image.alpha_composite(img_with_segments, overlay)
         
+        # Добавляем текстовые метки с цветами на изображение
+        draw_final = ImageDraw.Draw(img_with_segments)
+        
+        # Загружаем шрифт
+        try:
+            font = ImageFont.truetype("/System/Library/Fonts/Helvetica.ttc", 18)
+        except:
+            try:
+                font = ImageFont.load_default()
+            except:
+                font = None
+        
+        for seg_info in segments_info:
+            label = seg_info['label']
+            score = seg_info['score']
+            center_x, center_y = seg_info['center']
+            color_rgb = seg_info['color']
+            
+            # Формируем текст метки
+            text = f"{label}: {score:.2f}"
+            
+            # Получаем размер текста
+            if font:
+                bbox = draw_final.textbbox((0, 0), text, font=font)
+                text_width = bbox[2] - bbox[0]
+                text_height = bbox[3] - bbox[1]
+            else:
+                text_width = len(text) * 7
+                text_height = 14
+            
+            # Вычисляем позицию текста (центрируем относительно центра сегмента)
+            text_x = center_x - text_width // 2
+            text_y = center_y - text_height // 2
+            
+            # Ограничиваем координаты границами изображения
+            img_width, img_height = img_with_segments.size
+            text_x = max(2, min(text_x, img_width - text_width - 2))
+            text_y = max(2, min(text_y, img_height - text_height - 2))
+            
+            # Рисуем фон для текста (полупрозрачный черный для читаемости)
+            padding = 4
+            draw_final.rectangle(
+                [text_x - padding, text_y - padding, 
+                 text_x + text_width + padding, text_y + text_height + padding],
+                fill=(0, 0, 0, 180)  # Полупрозрачный черный фон
+            )
+            
+            # Рисуем текст цветом сегмента
+            draw_final.text(
+                (text_x, text_y),
+                text,
+                fill=color_rgb + (255,),  # RGB + альфа для RGBA
+                font=font
+            )
+        
         # Конвертируем обратно в RGB для отображения
         img_with_segments = img_with_segments.convert("RGB")
         
@@ -1391,7 +1524,8 @@ with gr.Blocks(title="Трансформеры Hugging Face", theme=gr.themes.So
                         tts_model = gr.Dropdown(
                             choices=[
                                 "microsoft/speecht5_tts",
-                                "facebook/mms-tts-eng"
+                                "facebook/mms-tts-eng",
+                                "facebook/mms-tts-rus"
                             ],
                             value="microsoft/speecht5_tts",
                             label="Выберите модель"