Update app.py

app.py

@@ -1,424 +1,64 @@
 import gradio as gr
-import pandas as pd
-from datetime import datetime
-from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
+from transformers import pipeline
 import time
-import warnings
-warnings.filterwarnings('ignore')
 
-# Глобальные переменные
-history = []
-MAX_INPUT_LENGTH = 2000
-
-# Доступные модели для классификации тональности
-MODELS = {
-    "distilbert-base-uncased-finetuned-sst-2-english": {
-        "name": "DistilBERT SST-2",
-        "description": "Быстрая модель для бинарной классификации (позитив/негатив)",
-        "max_length": 512
-    },
-    "nlptown/bert-base-multilingual-uncased-sentiment": {
-        "name": "BERT Multilingual Sentiment",
-        "description": "Многоязычная модель с 5 классами (1-5 звёзд)",
-        "max_length": 512
-    },
-    "cardiffnlp/twitter-roberta-base-sentiment-latest": {
-        "name": "Twitter-RoBERTa",
-        "description": "Модель, обученная на твитах, 3 класса (негатив/нейтрал/позитив)",
-        "max_length": 512
-    }
-}
-
-# Инициализация моделей
-loaded_models = {}
-
-def load_model(model_id):
-    """Загрузка модели по требованию"""
-    if model_id not in loaded_models:
-        print(f"Загрузка модели {model_id}...")
-        try:
-            tokenizer = AutoTokenizer.from_pretrained(model_id)
-            model = AutoModelForSequenceClassification.from_pretrained(model_id)
-            classifier = pipeline(
-                "sentiment-analysis",
-                model=model,
-                tokenizer=tokenizer,
-                truncation=True,
-                max_length=MODELS[model_id]["max_length"]
-            )
-            loaded_models[model_id] = classifier
-            print(f"Модель {model_id} загружена успешно")
-        except Exception as e:
-            print(f"Ошибка загрузки модели: {e}")
-            return None
-    return loaded_models[model_id]
-
-def predict_sentiment(text, model_id, temperature=1.0):
-    """
-    Предсказание тональности текста
-    
-    Args:
-        text: Входной текст
-        model_id: Идентификатор модели
-        temperature: Параметр для смягчения предсказаний (не используется в классификации,
-                    но оставлен для единообразия интерфейса)
-    
-    Returns:
-        dict: Результаты классификации
-    """
-    # Проверка ввода
+# Простая функция для тестирования
+def analyze_coffee_sentiment(text):
     if not text or not text.strip():
-        return {"error": "Введите текст для анализа"}
-    
-    if len(text) > MAX_INPUT_LENGTH:
-        return {"error": f"Текст слишком длинный. Максимум {MAX_INPUT_LENGTH} символов"}
-    
-    # Загрузка модели
-    classifier = load_model(model_id)
-    if classifier is None:
-        return {"error": "Ошибка загрузки модели"}
-    
-    # Измерение времени выполнения
-    start_time = time.time()
-    
-    try:
-        # Выполнение предсказания
-        result = classifier(text[:MODELS[model_id]["max_length"] * 4])[0]
-        
-        # Форматирование результата в зависимости от модели
-        if model_id == "nlptown/bert-base-multilingual-uncased-sentiment":
-            # Преобразование оценки 1-5 в текстовую форму
-            stars = int(result['label'].split()[0])
-            if stars <= 2:
-                sentiment = "Негативный"
-                emoji = "😞"
-            elif stars == 3:
-                sentiment = "Нейтральный"
-                emoji = "😐"
-            else:
-                sentiment = "Позитивный"
-                emoji = "😊"
-            
-            confidence = result['score']
-            label = f"{stars} звёзд"
-        else:
-            # Для других моделей
-            label_map = {
-                "POSITIVE": "Позитивный",
-                "NEGATIVE": "Негативный",
-                "NEUTRAL": "Нейтральный",
-                "LABEL_0": "Негативный",
-                "LABEL_1": "Нейтральный",
-                "LABEL_2": "Позитивный"
-            }
-            
-            original_label = result['label']
-            sentiment = label_map.get(original_label, original_label)
-            confidence = result['score']
-            
-            # Эмодзи для визуализации
-            if "позитив" in sentiment.lower():
-                emoji = "😊"
-            elif "негатив" in sentiment.lower():
-                emoji = "😞"
-            else:
-                emoji = "😐"
-            
-            label = original_label
-        
-        latency = time.time() - start_time
-        
-        # Сохранение в историю
-        history_entry = {
-            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "text": text[:100] + "..." if len(text) > 100 else text,
-            "model": MODELS[model_id]["name"],
-            "sentiment": sentiment,
-            "confidence": round(confidence, 3),
-            "latency": round(latency, 3)
-        }
-        history.insert(0, history_entry)
-        
-        # Ограничение истории
-        if len(history) > 10:
-            history.pop()
-        
-        return {
-            "sentiment": sentiment,
-            "confidence": confidence,
-            "label": label,
-            "latency": latency,
-            "emoji": emoji,
-            "model_name": MODELS[model_id]["name"],
-            "error": None
-        }
-        
-    except Exception as e:
-        return {"error": f"Ошибка обработки: {str(e)}"}
-
-def batch_process(file, model_id):
-    """Пакетная обработка CSV файла"""
-    if file is None:
-        return None, "Загрузите CSV файл"
+        return "⚠️ Введите текст отзыва о кофе", "0ms"
     
     try:
-        # Чтение CSV
-        df = pd.read_csv(file.name)
+        start_time = time.time()
         
-        # Проверка наличия колонки с текстом
-        if 'text' not in df.columns:
-            # Попробуем найти колонку с текстом
-            text_columns = [col for col in df.columns if any(word in col.lower() for word in ['text', 'review', 'comment', 'отзыв'])]
-            if text_columns:
-                df['text'] = df[text_columns[0]]
-            else:
-                return None, "Не найдена колонка 'text' или аналогичная"
+        # Используем легкую модель для быстрого старта
+        classifier = pipeline(
+            "sentiment-analysis",
+            model="distilbert-base-uncased-finetuned-sst-2-english"
+        )
         
-        results = []
-        total_texts = min(len(df), 50)  # Ограничим количество для скорости
+        result = classifier(text[:500])[0]
+        latency = f"{(time.time() - start_time)*1000:.0f}ms"
         
-        with gr.Progress() as progress:
-            task = progress.add_task("Обработка...", total=total_texts)
-            
-            for i, row in progress.tqdm(enumerate(df.head(total_texts).itertuples()), total=total_texts):
-                text = str(getattr(row, 'text'))
-                if len(text) > 500:
-                    text = text[:500] + "..."
-                
-                result = predict_sentiment(text, model_id)
-                if "error" not in result or result["error"] is None:
-                    results.append({
-                        "Текст": text[:100] + "..." if len(text) > 100 else text,
-                        "Тональность": result["sentiment"],
-                        "Уверенность": round(result["confidence"], 3),
-                        "Модель": result["model_name"]
-                    })
-                
-                progress.update(task, advance=1)
+        sentiment = "😊 Позитивный" if result['label'] == "POSITIVE" else "😞 Негативный"
+        confidence = f"{result['score']:.1%}"
         
-        results_df = pd.DataFrame(results)
-        return results_df, f"Обработано {len(results)} отзывов"
+        return f"{sentiment} (уверенность: {confidence})", latency
         
     except Exception as e:
-        return None, f"Ошибка обработки файла: {str(e)}"
-
-def get_history_html():
-    """Получение истории в HTML формате"""
-    if not history:
-        return "<p>История пуста</p>"
-    
-    html = "<div style='max-height: 300px; overflow-y: auto;'>"
-    html += "<table style='width: 100%; border-collapse: collapse;'>"
-    html += "<tr style='background-color: #f2f2f2;'><th>Время</th><th>Текст</th><th>Модель</th><th>Тональность</th><th>Уверенность</th><th>Время, сек</th></tr>"
-    
-    for entry in history:
-        html += f"""
-        <tr style='border-bottom: 1px solid #ddd;'>
-            <td>{entry['timestamp']}</td>
-            <td>{entry['text']}</td>
-            <td>{entry['model']}</td>
-            <td>{entry['sentiment']}</td>
-            <td>{entry['confidence']}</td>
-            <td>{entry['latency']}</td>
-        </tr>
-        """
-    
-    html += "</table></div>"
-    return html
+        return f"❌ Ошибка: {str(e)}", "0ms"
 
-def calculate_metrics():
-    """Расчёт простых метрик качества"""
-    # Тестовые примеры с ожидаемой тональностью
-    test_cases = [
-        {"text": "This coffee is absolutely amazing! Best I've ever had.", "expected": "POSITIVE"},
-        {"text": "The coffee was cold and tasted bitter. Very disappointing.", "expected": "NEGATIVE"},
-        {"text": "I ordered a coffee. It was delivered on time.", "expected": "NEUTRAL"},
-        {"text": "Ароматный кофе с приятным послевкусием. Рекомендую!", "expected": "POSITIVE"},
-        {"text": "Кофе был пережарен, чувствуется горечь. Не понравилось.", "expected": "NEGATIVE"}
-    ]
-    
-    results = []
-    model_id = list(MODELS.keys())[0]  # Используем первую модель
-    
-    for test in test_cases:
-        result = predict_sentiment(test["text"], model_id)
-        if "error" not in result or result["error"] is None:
-            predicted = "POSITIVE" if "позитив" in result["sentiment"].lower() else \
-                       "NEGATIVE" if "негатив" in result["sentiment"].lower() else "NEUTRAL"
-            results.append({
-                "text": test["text"][:50] + "...",
-                "expected": test["expected"],
-                "predicted": predicted,
-                "correct": predicted == test["expected"]
-            })
-    
-    accuracy = sum(1 for r in results if r["correct"]) / len(results) if results else 0
-    
-    return pd.DataFrame(results), f"Точность на тестовых примерах: {accuracy:.2%}"
-
-# Создание интерфейса Gradio
-with gr.Blocks(title="Анализ тональности отзывов о кофе", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# ☕ Анализ тональности отзывов о кофе")
-    gr.Markdown("Определите эмоциональную окраску отзывов о кофе с помощью нейросетевых моделей")
+# Минимальный интерфейс
+with gr.Blocks(title="Анализатор тональности кофе") as demo:
+    gr.Markdown("# ☕ Анализатор тональности отзывов о кофе")
     
     with gr.Row():
-        with gr.Column(scale=2):
-            # Входные данные
-            input_text = gr.Textbox(
-                label="Введите отзыв о кофе",
-                placeholder="Например: Этот кофе имеет богатый аромат и приятное послевкусие...",
-                lines=4,
-                max_lines=8
-            )
-            
-            # Выбор модели
-            model_dropdown = gr.Dropdown(
-                choices=list(MODELS.keys()),
-                value=list(MODELS.keys())[0],
-                label="Выберите модель",
-                info=[f"{MODELS[m]['name']}: {MODELS[m]['description']}" for m in MODELS][0]
-            )
-            
-            # Параметры
-            temperature = gr.Slider(
-                minimum=0.1,
-                maximum=2.0,
-                value=1.0,
-                step=0.1,
-                label="Температура (влияет на уверенность)",
-                info="Меньше = более уверенные предсказания"
-            )
-            
-            # Кнопки
-            with gr.Row():
-                submit_btn = gr.Button("📊 Анализировать", variant="primary")
-                clear_btn = gr.Button("🗑️ Очистить")
-                metrics_btn = gr.Button("📈 Тестовые метрики")
-            
-            # Примеры
-            gr.Examples(
-                examples=[
-                    ["Этот кофе просто восхитителен! Идеальный баланс кислотности и горечи.", list(MODELS.keys())[0]],
-                    ["Кофе был холодным и безвкусным. Очень разочарован.", list(MODELS.keys())[0]],
-                    ["Заказал капучино. Доставка заняла 15 минут.", list(MODELS.keys())[1]],
-                    ["Кофе имеет насыщенный вкус с нотками шоколада и ореха. Рекомендую!", list(MODELS.keys())[2]],
-                    ["Горький и пережаренный кофе. Никому не советую покупать.", list(MODELS.keys())[2]]
-                ],
-                inputs=[input_text, model_dropdown],
-                label="Примеры отзывов"
-            )
-        
-        with gr.Column(scale=1):
-            # Результаты
-            result_emoji = gr.Textbox(label="Результат", interactive=False)
-            result_sentiment = gr.Textbox(label="Тональность", interactive=False)
-            result_confidence = gr.Textbox(label="Уверенность", interactive=False)
-            result_latency = gr.Textbox(label="Время обработки", interactive=False)
-            result_model = gr.Textbox(label="Использованная модель", interactive=False)
-    
-    # История запросов
-    with gr.Accordion("📜 История запросов (последние 10)", open=False):
-        history_html = gr.HTML(value=get_history_html())
-        refresh_history = gr.Button("🔄 Обновить историю")
-    
-    # Пакетная обработка
-    with gr.Accordion("📁 Пакетная обработка CSV", open=False):
-        gr.Markdown("Загрузите CSV файл с колонкой 'text' для обработки нескольких отзывов")
-        file_input = gr.File(label="CSV файл", file_types=[".csv"])
-        batch_model_dropdown = gr.Dropdown(
-            choices=list(MODELS.keys()),
-            value=list(MODELS.keys())[0],
-            label="Модель для пакетной обработки"
+        text_input = gr.Textbox(
+            label="Введите отзыв о кофе",
+            placeholder="Пример: Этот кофе имеет богатый аромат...",
+            lines=3
         )
-        batch_btn = gr.Button("🚀 Обработать файл", variant="secondary")
-        batch_output = gr.Dataframe(label="Результаты пакетной обработки")
-        batch_status = gr.Textbox(label="Статус", interactive=False)
-    
-    # Тестовые метрики
-    with gr.Accordion("📊 Тестирование качества модели", open=False):
-        metrics_output = gr.Dataframe(label="Результаты тестирования")
-        metrics_status = gr.Textbox(label="Метрики", interactive=False)
-    
-    # Обработчики событий
-    def update_result(text, model_id, temp):
-        result = predict_sentiment(text, model_id, temp)
-        
-        if "error" in result and result["error"]:
-            return [
-                "❌ Ошибка",
-                f"Ошибка: {result['error']}",
-                "-",
-                "-",
-                "-",
-                get_history_html()
-            ]
-        
-        return [
-            f"{result['emoji']} {result['sentiment']}",
-            result['sentiment'],
-            f"{result['confidence']:.2%}",
-            f"{result['latency']:.3f} сек",
-            result['model_name'],
-            get_history_html()
-        ]
     
-    # Связывание обработчиков
-    submit_btn.click(
-        fn=update_result,
-        inputs=[input_text, model_dropdown, temperature],
-        outputs=[result_emoji, result_sentiment, result_confidence, result_latency, result_model, history_html]
-    )
-    
-    clear_btn.click(
-        fn=lambda: ["", list(MODELS.keys())[0], 1.0, "", "", "", "", "", get_history_html()],
-        outputs=[input_text, model_dropdown, temperature, result_emoji, result_sentiment, 
-                 result_confidence, result_latency, result_model, history_html]
-    )
-    
-    refresh_history.click(
-        fn=get_history_html,
-        outputs=history_html
-    )
-    
-    batch_btn.click(
-        fn=batch_process,
-        inputs=[file_input, batch_model_dropdown],
-        outputs=[batch_output, batch_status]
-    )
+    analyze_btn = gr.Button("Анализировать", variant="primary")
     
-    metrics_btn.click(
-        fn=calculate_metrics,
-        outputs=[metrics_output, metrics_status]
+    with gr.Row():
+        result_output = gr.Textbox(label="Результат")
+        time_output = gr.Textbox(label="Время выполнения")
+    
+    # Примеры
+    gr.Examples(
+        examples=[
+            ["This coffee is absolutely amazing! Best I've ever had."],
+            ["Кофе был холодным и безвкусным. Очень разочарован."],
+            ["Standard coffee, nothing special. Acceptable for the price."]
+        ],
+        inputs=text_input
     )
     
-    # Информация о модели при изменении выбора
-    def update_model_info(model_id):
-        model_info = MODELS.get(model_id, {})
-        return gr.Dropdown.update(info=f"{model_info.get('name', '')}: {model_info.get('description', '')}")
-    
-    model_dropdown.change(
-        fn=update_model_info,
-        inputs=model_dropdown,
-        outputs=model_dropdown
+    analyze_btn.click(
+        fn=analyze_coffee_sentiment,
+        inputs=text_input,
+        outputs=[result_output, time_output]
     )
-    
-    # Предзагрузка первой модели
-    gr.Markdown("### Информация о моделях")
-    model_info_text = "Доступные модели:\n\n"
-    for model_id, info in MODELS.items():
-        model_info_text += f"**{info['name']}** (`{model_id}`)\n"
-        model_info_text += f"  - {info['description']}\n\n"
-    
-    gr.Markdown(model_info_text)
 
 if __name__ == "__main__":
-    # Предзагрузка первой модели
-    print("Предзагрузка моделей...")
-    for model_id in list(MODELS.keys())[:1]:  # Загружаем только первую для скорости
-        load_model(model_id)
-    
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )
+    demo.launch(debug=False)