Update app.py

app.py

@@ -1,11 +1,173 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import os
+import shutil
+import time
+import logging
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+# Настройка логирования
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
+# Информация о системе и CUDA
+logger.info("===== Запуск приложения =====")
+logger.info(f"PyTorch: {torch.__version__}")
+logger.info(f"CUDA доступен: {torch.cuda.is_available()}")
+
+if torch.cuda.is_available():
+    try:
+        cuda_device_count = torch.cuda.device_count()
+        logger.info(f"Количество CUDA устройств: {cuda_device_count}")
+        for i in range(cuda_device_count):
+            logger.info(f"CUDA устройство {i}: {torch.cuda.get_device_name(i)}")
+        logger.info(f"Текущее CUDA устройство: {torch.cuda.current_device()}")
+    except Exception as e:
+        logger.warning(f"Ошибка при получении информации о CUDA: {e}")
+else:
+    logger.info("CUDA недоступен, будет использоваться CPU")
+
+# Проверяем наличие общих директорий для хранения данных
+possible_dirs = [
+    "/data",           # Стандартный путь для Spaces с подключенным диском
+    "/mnt/data",       # Альтернативный путь для подключенного диска
+    "/home/user/data", # Директория пользователя
+    "/tmp"             # Временная директория (запасной вариант)
+]
+
+# Находим первую доступную директорию
+DISK_DIR = None
+for dir_path in possible_dirs:
+    try:
+        if not os.path.exists(dir_path):
+            os.makedirs(dir_path, exist_ok=True)
+        
+        # Проверяем, можем ли мы писать в эту директорию
+        test_file = os.path.join(dir_path, "write_test.txt")
+        with open(test_file, "w") as f:
+            f.write("test")
+        os.remove(test_file)
+        
+        DISK_DIR = dir_path
+        logger.info(f"Используем директорию для хранения: {DISK_DIR}")
+        break
+    except (OSError, PermissionError) as e:
+        logger.warning(f"Не удалось использовать директорию {dir_path}: {e}")
+
+if DISK_DIR is None:
+    DISK_DIR = "."  # Используем текущую директорию, если ничего не найдено
+    logger.warning(f"Внимание! Используем текущую директорию: {os.path.abspath(DISK_DIR)}")
+
+# Настраиваем пути для сохранения моделей
+CACHE_DIR = os.path.join(DISK_DIR, "models_cache")
+TORCH_HOME = os.path.join(DISK_DIR, "torch_home")
+OFFLOAD_DIR = os.path.join(DISK_DIR, "offload")
+
+# Создаем директории
+os.makedirs(CACHE_DIR, exist_ok=True)
+os.makedirs(TORCH_HOME, exist_ok=True)
+os.makedirs(OFFLOAD_DIR, exist_ok=True)
+
+# Устанавливаем переменные окружения для управления кэшированием
+os.environ["TRANSFORMERS_CACHE"] = CACHE_DIR
+os.environ["HF_HOME"] = CACHE_DIR
+os.environ["TORCH_HOME"] = TORCH_HOME
+
+# Функция для проверки свободного места на диске
+def check_disk_space(path):
+    try:
+        total, used, free = shutil.disk_usage(path)
+        logger.info(f"Диск {path}: всего {total // (1024**3)} ГБ, свободно {free // (1024**3)} ГБ")
+        return free
+    except Exception as e:
+        logger.warning(f"Не удалось проверить диск {path}: {e}")
+        return None
+
+# Выводим информацию о диске перед загрузкой
+logger.info("Информация о дисках перед загрузкой:")
+check_disk_space("/")
+check_disk_space(DISK_DIR)
+
+# Загрузка модели и токенизатора
+model_name = " KoDer123/Nerealnost_8M"
+
+# Глобальные переменные для модели
+model = None
+tokenizer = None
+is_model_loaded = False
+
+# Функция для загрузки модели
+def load_model():
+    global model, tokenizer, is_model_loaded
+    
+    try:
+        logger.info("Загружаем токенизатор...")
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name,
+            cache_dir=CACHE_DIR,
+            local_files_only=False
+        )
+        
+        # Устанавливаем pad_token, если его нет
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+        
+        logger.info("Загружаем модель...")
+        # Определяем оптимальный режим загрузки
+        model_kwargs = {
+            "cache_dir": CACHE_DIR,
+            "local_files_only": False,
+            "trust_remote_code": True
+        }
+        
+        # Проверяем доступность CUDA
+        if torch.cuda.is_available():
+            logger.info("Загружаем модель в режиме GPU...")
+            model_kwargs.update({
+                "device_map": "auto",
+                "torch_dtype": torch.float16,
+            })
+        else:
+            logger.info("Загружаем модель в режиме CPU...")
+            model_kwargs.update({
+                "device_map": "cpu",
+                "torch_dtype": torch.float32,
+                "low_cpu_mem_usage": True,
+                "offload_folder": OFFLOAD_DIR
+            })
+        
+        # Загружаем модель
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            **model_kwargs
+        )
+        
+        # Проверяем, на каком устройстве размещена модель
+        device_info = next(model.parameters()).device
+        logger.info(f"Модель успешно загружена на устройство: {device_info}")
+        
+        is_model_loaded = True
+        return "Модель успешно загружена"
+    except Exception as e:
+        error_msg = str(e)
+        logger.error(f"Ошибка загрузки модели: {error_msg}")
+        is_model_loaded = False
+        return f"Ошибка загрузки модели: {error_msg}"
+
+# Загружаем модель
+start_time = time.time()
+load_result = load_model()
+end_time = time.time()
+logger.info(f"Загрузка модели заняла {end_time - start_time:.2f} секунд. Результат: {load_result}")
+
+# Выводим информацию о диске после загрузки
+logger.info("Информация о дисках после загрузки:")
+check_disk_space("/")
+check_disk_space(DISK_DIR)
+
+# Определяем шаблон Q&A, как при обучении
+qa_prompt = "<s>Пользователь: {}\nАссистент: {}"
+EOS_TOKEN = tokenizer.eos_token if tokenizer.eos_token else "</s>"
 
 def respond(
     message,
@@ -15,50 +177,159 @@ def respond(
     temperature,
     top_p,
 ):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+    global model, tokenizer, is_model_loaded
+    
+    # Проверяем, загружена ли модель
+    if not is_model_loaded or model is None:
+        return "Модель не загружена или произошла ошибка при загрузке."
+    
+    # Замеряем время
+    start_time = time.time()
+    
+    # Формируем историю в текстовом формате
+    full_prompt = ""
+    if system_message:
+        full_prompt += qa_prompt.format(system_message, "") + "\n"
+
+    for user_msg, assistant_msg in history:
+        if user_msg and assistant_msg:
+            full_prompt += qa_prompt.format(user_msg, assistant_msg) + EOS_TOKEN + "\n"
+
+    full_prompt += qa_prompt.format(message, "")
+    
+    logger.info(f"Генерируем ответ на запрос: '{message[:50]}...' (длина промпта: {len(full_prompt)})")
+    
+    try:
+        # Токенизация входных данных
+        inputs = tokenizer(full_prompt, return_tensors="pt").to(model.device)
+        
+        # Генерация ответа
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            do_sample=True,
+            pad_token_id=tokenizer.pad_token_id,
+        )
+        
+        # Декодирование полного вывода
+        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Извлекаем только часть после "Ассистент: "
+        response_start = generated_text.rfind("Ассистент: ") + len("Ассистент: ")
+        response = generated_text[response_start:].strip()
+        
+        end_time = time.time()
+        generation_time = end_time - start_time
+        logger.info(f"Генерация заняла {generation_time:.2f} секунд. Получен ответ длиной {len(response)} символов")
+        
+        return response
+    except Exception as e:
+        logger.error(f"Ошибка при генерации ответа: {str(e)}")
+        return f"Произошла ошибка при генерации ответа: {str(e)}"
 
+# Настройка интерфейса Gradio
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# НереальностьQA - Чат с экспертом по эзотерике")
+    
+    with gr.Row():
+        with gr.Column(scale=4):
+            chatbot = gr.Chatbot(label="Диалог")
+            user_input = gr.Textbox(
+                placeholder="Введите ваш вопрос здесь...",
+                label="Ваш вопрос",
+                lines=2
+            )
+            
+            with gr.Row():
+                submit_btn = gr.Button("Отправить", variant="primary")
+                clear_btn = gr.Button("Очистить историю")
+            
+        with gr.Column(scale=1):
+            with gr.Accordion("Настройки генерации", open=False):
+                system_msg = gr.Textbox(
+                    value="Ты - эксперт по эзотерике, специализирующийся на энергетике человека, мире отшедших душ и метафизических знаниях. Отвечай подробно, опираясь на свои знания.",
+                    label="Системное сообщение",
+                    lines=4
+                )
+                max_tokens = gr.Slider(
+                    minimum=1,
+                    maximum=2048,
+                    value=512,
+                    step=1,
+                    label="Максимальное число токенов"
+                )
+                temperature = gr.Slider(
+                    minimum=0.1,
+                    maximum=4.0,
+                    value=0.7,
+                    step=0.1,
+                    label="Температура"
+                )
+                top_p = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.95,
+                    step=0.05,
+                    label="Top-p"
+                )
+            
+            with gr.Accordion("Информация", open=True):
+                info_text = gr.Markdown(f"""
+                * **Модель**: {model_name}
+                * **Режим работы**: {"GPU" if torch.cuda.is_available() else "CPU"}
+                * **Директория для кэша**: {CACHE_DIR}
+                """)
+    
+    # Примеры вопросов
+    with gr.Accordion("Примеры вопросов", open=True):
+        examples = gr.Examples(
+            examples=[
+                "Что известно о мире отшедших душ и их взаимодействии с нашим миром?",
+                "Что такое энергетическая ось человека и как она связана с его биополем?",
+                "Расскажи о роли энергии мысли и желания в мире отшедших."
+            ],
+            inputs=user_input
+        )
+    
+    # Функция обработки отправки сообщения
+    def chat(message, history):
+        if message == "":
+            return history, ""
+        
+        # Генерируем ответ
+        bot_message = respond(
+            message, 
+            history, 
+            system_msg.value, 
+            max_tokens.value, 
+            temperature.value, 
+            top_p.value
+        )
+        
+        # Добавляем в историю и возвращаем
+        history = history + [(message, bot_message)]
+        return history, ""
+    
+    # Обработчики событий
+    submit_btn.click(
+        chat,
+        inputs=[user_input, chatbot],
+        outputs=[chatbot, user_input]
+    )
+    
+    user_input.submit(
+        chat,
+        inputs=[user_input, chatbot],
+        outputs=[chatbot, user_input]
+    )
+    
+    clear_btn.click(
+        lambda: ([], ""),
+        outputs=[chatbot, user_input]
+    )
 
+# Запуск приложения
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()