Upload folder using huggingface_hub

API_ENDPOINT.md

@@ -0,0 +1,279 @@
+# API Endpoint для модели Code Analyzer
+
+Модель доступна через API endpoint в Gradio Space.
+
+## Использование API
+
+### URL Endpoint
+
+Если ваш Gradio Space доступен по адресу: `https://YOUR_USERNAME-code-analyzer-demo.hf.space`
+
+То API endpoint будет: `https://YOUR_USERNAME-code-analyzer-demo.hf.space/api/predict`
+
+### Формат запроса
+
+**Метод:** POST  
+**Content-Type:** application/json
+
+**Body:**
+```json
+{
+  "data": [
+    "Условие задачи",
+    "Код студента"
+  ]
+}
+```
+
+### Формат ответа
+
+```json
+{
+  "data": [
+    {
+      "summary": "...",
+      "tags": [...],
+      "overall_score": 10,
+      ...
+    },
+    "JSON строка"
+  ]
+}
+```
+
+## Примеры использования
+
+### Python
+
+```python
+import requests
+import json
+
+# URL вашего Gradio Space
+SPACE_URL = "https://YOUR_USERNAME-code-analyzer-demo.hf.space"
+
+def analyze_code(task, code):
+    """Анализирует код через API"""
+    api_url = f"{SPACE_URL}/api/predict"
+    
+    payload = {
+        "data": [task, code]
+    }
+    
+    response = requests.post(api_url, json=payload)
+    result = response.json()
+    
+    # Gradio возвращает результат в формате {"data": [json_obj, json_str]}
+    if "data" in result and len(result["data"]) > 0:
+        # Первый элемент - это JSON объект
+        return result["data"][0]
+    return result
+
+# Использование
+task = "Напишите функцию для вычисления суммы списка"
+code = """def sum_list(numbers):
+    return sum(numbers)"""
+
+result = analyze_code(task, code)
+print(json.dumps(result, ensure_ascii=False, indent=2))
+```
+
+### JavaScript/Node.js
+
+```javascript
+const axios = require('axios');
+
+const SPACE_URL = 'https://YOUR_USERNAME-code-analyzer-demo.hf.space';
+
+async function analyzeCode(task, code) {
+    try {
+        const response = await axios.post(
+            `${SPACE_URL}/api/predict`,
+            {
+                data: [task, code]
+            }
+        );
+        
+        // Gradio возвращает {"data": [json_obj, json_str]}
+        return response.data.data[0];
+    } catch (error) {
+        console.error('Ошибка:', error.message);
+        throw error;
+    }
+}
+
+// Использование
+analyzeCode(
+    "Напишите функцию для суммы списка",
+    "def sum_list(numbers):\n    return sum(numbers)"
+).then(result => {
+    console.log(JSON.stringify(result, null, 2));
+});
+```
+
+### cURL
+
+```bash
+curl -X POST https://YOUR_USERNAME-code-analyzer-demo.hf.space/api/predict \
+  -H "Content-Type: application/json" \
+  -d '{
+    "data": [
+      "Напишите функцию для вычисления суммы списка",
+      "def sum_list(numbers):\n    return sum(numbers)"
+    ]
+  }'
+```
+
+### PHP
+
+```php
+<?php
+$spaceUrl = 'https://YOUR_USERNAME-code-analyzer-demo.hf.space/api/predict';
+
+$task = "Напишите функцию для вычисления суммы списка";
+$code = "def sum_list(numbers):\n    return sum(numbers)";
+
+$data = [
+    'data' => [$task, $code]
+];
+
+$ch = curl_init($spaceUrl);
+curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+curl_setopt($ch, CURLOPT_POST, true);
+curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
+curl_setopt($ch, CURLOPT_HTTPHEADER, [
+    'Content-Type: application/json'
+]);
+
+$response = curl_exec($ch);
+curl_close($ch);
+
+$result = json_decode($response, true);
+$analysis = $result['data'][0]; // JSON объект с анализом
+
+echo json_encode($analysis, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
+?>
+```
+
+## Интеграция в Backend
+
+### FastAPI
+
+```python
+from fastapi import FastAPI
+import requests
+
+app = FastAPI()
+SPACE_URL = "https://YOUR_USERNAME-code-analyzer-demo.hf.space"
+
+@app.post("/analyze")
+async def analyze_code(request: dict):
+    task = request.get("task")
+    code = request.get("code")
+    
+    # Вызов Gradio API
+    response = requests.post(
+        f"{SPACE_URL}/api/predict",
+        json={"data": [task, code]},
+        timeout=180  # 3 минуты для CPU
+    )
+    
+    result = response.json()
+    return {"success": True, "analysis": result["data"][0]}
+```
+
+### Express.js
+
+```javascript
+const express = require('express');
+const axios = require('axios');
+
+const app = express();
+app.use(express.json());
+
+const SPACE_URL = 'https://YOUR_USERNAME-code-analyzer-demo.hf.space';
+
+app.post('/analyze', async (req, res) => {
+    const { task, code } = req.body;
+    
+    try {
+        const response = await axios.post(
+            `${SPACE_URL}/api/predict`,
+            { data: [task, code] },
+            { timeout: 180000 } // 3 минуты
+        );
+        
+        res.json({
+            success: true,
+            analysis: response.data.data[0]
+        });
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+app.listen(8000);
+```
+
+## Обработка ошибок
+
+```python
+import requests
+import time
+
+def analyze_with_retry(task, code, max_retries=3):
+    """Анализ с повторными попытками"""
+    for attempt in range(max_retries):
+        try:
+            response = requests.post(
+                f"{SPACE_URL}/api/predict",
+                json={"data": [task, code]},
+                timeout=180
+            )
+            
+            if response.status_code == 200:
+                return response.json()["data"][0]
+            else:
+                print(f"Ошибка {response.status_code}: {response.text}")
+                
+        except requests.exceptions.Timeout:
+            print(f"Таймаут на попытке {attempt + 1}")
+            if attempt < max_retries - 1:
+                time.sleep(5)  # Ждем 5 секунд перед повтором
+        except Exception as e:
+            print(f"Ошибка: {e}")
+            if attempt < max_retries - 1:
+                time.sleep(5)
+    
+    return None
+```
+
+## Ограничения
+
+- **Таймаут:** Рекомендуется устанавливать таймаут 180 секунд (3 минуты) для CPU
+- **Rate Limiting:** Gradio Space может иметь ограничения на количество запросов
+- **Очередь:** Если Space занят, запрос может быть поставлен в очередь
+
+## Альтернатива: Прямое использование модели
+
+Если нужен более надежный API, можно развернуть модель локально или на своем сервере:
+
+```python
+# См. BACKEND_INTEGRATION.md для примеров
+from transformers import AutoModelForCausalLM, AutoTokenizer
+# ... (полный код в BACKEND_INTEGRATION.md)
+```
+
+## Получение URL вашего Space
+
+1. Перейдите на https://huggingface.co/spaces
+2. Найдите ваш Space
+3. Скопируйте URL (например: `https://username-code-analyzer-demo.hf.space`)
+4. Используйте `/api/predict` для API endpoint
+
+---
+
+**Готово!** Теперь вы можете использовать модель через API из любого проекта.

API_USAGE.md

@@ -0,0 +1,333 @@
+# Использование модели через Hugging Face API
+
+Эта модель доступна на Hugging Face и может быть использована другими пользователями через несколько способов.
+
+## Способ 1: Использование через transformers (рекомендуется)
+
+### Установка зависимостей
+
+```bash
+pip install transformers torch
+```
+
+### Базовый пример
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import json
+
+# Имя модели на Hugging Face
+model_name = "Vilyam888/Code_analyze.1.0"
+
+# Загрузка модели и токенизатора
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+# Условие задачи
+task = "Напишите функцию, которая принимает список чисел и возвращает сумму всех элементов."
+
+# Код студента
+code = """def sum_list(numbers):
+    total = 0
+    for num in numbers:
+        total += num
+    return total"""
+
+# Форматирование входа
+input_text = f"Задача:\n{task}\n\nРешение (код):\n```python\n{code}\n```"
+prompt = f"{input_text}\n\nОтвет:\n"
+
+# Генерация анализа
+inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+with torch.no_grad():
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=600,
+        temperature=0.7,
+        top_p=0.85,
+        top_k=20,
+        repetition_penalty=1.05,
+        do_sample=True,
+        pad_token_id=tokenizer.eos_token_id
+    )
+
+# Декодирование и парсинг JSON
+response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+result = response.split("Ответ:")[-1].strip()
+analysis = json.loads(result)
+
+print(json.dumps(analysis, ensure_ascii=False, indent=2))
+```
+
+## Способ 2: Использование через Hugging Face Inference API
+
+Если Inference API доступен для вашей модели, можно использовать его:
+
+```python
+import requests
+import json
+
+API_URL = "https://api-inference.huggingface.co/models/Vilyam888/Code_analyze.1.0"
+headers = {"Authorization": "Bearer YOUR_HF_TOKEN"}  # Замените на ваш токен
+
+def analyze_code(task, code):
+    # Форматирование входа
+    input_text = f"Задача:\n{task}\n\nРешение (код):\n```python\n{code}\n```"
+    prompt = f"{input_text}\n\nОтвет:\n"
+    
+    payload = {
+        "inputs": prompt,
+        "parameters": {
+            "max_new_tokens": 600,
+            "temperature": 0.7,
+            "top_p": 0.85,
+            "top_k": 20,
+            "repetition_penalty": 1.05,
+            "return_full_text": False
+        }
+    }
+    
+    response = requests.post(API_URL, headers=headers, json=payload)
+    result = response.json()
+    
+    # Извлечение текста
+    if isinstance(result, list) and len(result) > 0:
+        generated_text = result[0].get("generated_text", "")
+    else:
+        generated_text = result.get("generated_text", "")
+    
+    # Парсинг JSON
+    try:
+        analysis = json.loads(generated_text)
+        return analysis
+    except json.JSONDecodeError:
+        return {"raw_response": generated_text}
+
+# Пример использования
+task = "Напишите функцию для вычисления факториала."
+code = """def factorial(n):
+    if n <= 1:
+        return 1
+    return n * factorial(n-1)"""
+
+result = analyze_code(task, code)
+print(json.dumps(result, ensure_ascii=False, indent=2))
+```
+
+**Примечание:** Для использования Inference API нужен токен Hugging Face. Получите его на https://huggingface.co/settings/tokens
+
+## Способ 3: Использование через Gradio API (если создан Space)
+
+Если вы создали Gradio Space, можно использовать его API:
+
+```python
+import requests
+import json
+
+# URL вашего Gradio Space
+SPACE_URL = "https://YOUR_USERNAME-code-analyzer-demo.hf.space"  # Замените на ваш URL
+
+def analyze_via_gradio(task, code):
+    # Gradio API endpoint
+    api_url = f"{SPACE_URL}/api/predict"
+    
+    payload = {
+        "data": [task, code]
+    }
+    
+    response = requests.post(api_url, json=payload)
+    result = response.json()
+    
+    # Gradio возвращает результат в формате {"data": [...]}
+    if "data" in result and len(result["data"]) > 0:
+        return result["data"][0]  # JSON объект
+    return result
+
+# Пример использования
+task = "Напишите функцию для вычисления суммы списка."
+code = "def sum_list(numbers):\n    return sum(numbers)"
+
+result = analyze_via_gradio(task, code)
+print(json.dumps(result, ensure_ascii=False, indent=2))
+```
+
+## Способ 4: Использование готовых скриптов из репозитория
+
+Склонируйте репозиторий и используйте готовые примеры:
+
+```bash
+git clone https://huggingface.co/Vilyam888/Code_analyze.1.0
+cd Code_analyze.1.0
+```
+
+Или используйте примеры из этого проекта:
+- `scripts/quick_start_example.py` - минимальный пример
+- `scripts/use_model_example.py` - полный пример с интерактивным режимом
+- `models/merged/qwen_merged_full/inference.py` - функции для использования
+
+## Формат входных данных
+
+Модель ожидает два параметра:
+
+1. **task** (str): Условие задачи
+   ```
+   "Напишите функцию, которая принимает список чисел и возвращает сумму всех элементов."
+   ```
+
+2. **code** (str): Код решения студента
+   ```python
+   """def sum_list(numbers):
+       total = 0
+       for num in numbers:
+           total += num
+       return total"""
+   ```
+
+## Формат выходных данных
+
+Модель возвращает JSON объект в следующем формате:
+
+```json
+{
+  "summary": "Краткое резюме анализа",
+  "tags": [
+    {
+      "name": "Python",
+      "weight": 0.25,
+      "applied": true,
+      "score": 10,
+      "evidence": "Обоснование оценки"
+    }
+  ],
+  "overall_score": 10,
+  "code_quality_score": 9.5,
+  "correctness": {
+    "is_correct": true,
+    "score": 10,
+    "edge_cases_handled": true
+  },
+  "task_compliance": {
+    "is_relevant": true,
+    "score": 10,
+    "description": "Описание соответствия требованиям",
+    "missing_requirements": [],
+    "extra_features": []
+  },
+  "strengths": ["Сильные стороны решения"],
+  "weaknesses": ["Слабые стороны"],
+  "recommendations": ["Рекомендации по улучшению"],
+  "detailed_analysis": "Детальный анализ решения"
+}
+```
+
+## Примеры использования
+
+### Python
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import json
+
+model_name = "Vilyam888/Code_analyze.1.0"
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+def analyze(task, code):
+    input_text = f"Задача:\n{task}\n\nРешение (код):\n```python\n{code}\n```"
+    prompt = f"{input_text}\n\nОтвет:\n"
+    
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=600,
+            temperature=0.7,
+            top_p=0.85,
+            top_k=20,
+            repetition_penalty=1.05,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id
+        )
+    
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    result = response.split("Ответ:")[-1].strip()
+    return json.loads(result)
+
+# Использование
+result = analyze(
+    task="Напишите функцию для вычисления факториала",
+    code="def factorial(n):\n    return 1 if n <= 1 else n * factorial(n-1)"
+)
+print(json.dumps(result, ensure_ascii=False, indent=2))
+```
+
+### JavaScript/Node.js
+
+```javascript
+const fetch = require('node-fetch');
+const { pipeline } = require('@huggingface/inference');
+
+async function analyzeCode(task, code) {
+    const hf = new HfInference('YOUR_HF_TOKEN'); // Замените на ваш токен
+    
+    const inputText = `Задача:\n${task}\n\nРешение (код):\n\`\`\`python\n${code}\n\`\`\``;
+    const prompt = `${inputText}\n\nОтвет:\n`;
+    
+    const result = await hf.textGeneration({
+        model: 'Vilyam888/Code_analyze.1.0',
+        inputs: prompt,
+        parameters: {
+            max_new_tokens: 600,
+            temperature: 0.7,
+            top_p: 0.85,
+            top_k: 20,
+            repetition_penalty: 1.05
+        }
+    });
+    
+    const response = result.generated_text;
+    const jsonStr = response.split('Ответ:')[1]?.trim() || response;
+    
+    return JSON.parse(jsonStr);
+}
+
+// Использование
+analyzeCode(
+    "Напишите функцию для вычисления суммы списка",
+    "def sum_list(numbers):\n    return sum(numbers)"
+).then(result => console.log(JSON.stringify(result, null, 2)));
+```
+
+## Требования
+
+- Python 3.8+
+- PyTorch 2.0+
+- transformers 5.0+
+- ~6GB свободного места на диске (для загрузки модели)
+- GPU рекомендуется для быстрой работы (опционально)
+
+## Дополнительная информация
+
+- **Модель:** Vilyam888/Code_analyze.1.0
+- **Базовая модель:** Qwen/Qwen2.5-Coder-3B-Instruct
+- **Лицензия:** Apache 2.0
+- **Страница модели:** https://huggingface.co/Vilyam888/Code_analyze.1.0
+
+## Поддержка
+
+Если у вас возникли вопросы или проблемы:
+1. Проверьте документацию на странице модели
+2. Откройте issue в репозитории
+3. Используйте примеры из этого файла

BACKEND_INTEGRATION.md

@@ -0,0 +1,537 @@
+# Интеграция модели в Backend проект
+
+Примеры подключения модели Code Analyzer к различным backend фреймворкам.
+
+## Общая информация
+
+**Модель:** `Vilyam888/Code_analyze.1.0`  
+**Тип:** Text Generation (JSON ответ)  
+**Формат входа:** `task` (условие задачи) + `code` (код студента)  
+**Формат выхода:** JSON объект с анализом
+
+---
+
+## Python Backend
+
+### 1. FastAPI
+
+```python
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import json
+
+app = FastAPI(title="Code Analyzer API")
+
+# Глобальные переменные для модели
+model = None
+tokenizer = None
+MODEL_NAME = "Vilyam888/Code_analyze.1.0"
+
+class AnalysisRequest(BaseModel):
+    task: str
+    code: str
+
+class AnalysisResponse(BaseModel):
+    success: bool
+    analysis: dict
+
+@app.on_event("startup")
+async def load_model():
+    """Загружает модель при старте сервера"""
+    global model, tokenizer
+    print("Загрузка модели...")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_NAME,
+        torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+        device_map="auto",
+        trust_remote_code=True
+    )
+    print("Модель загружена!")
+
+def build_input(task, code):
+    """Форматирует вход"""
+    parts = []
+    if task.strip():
+        parts.append(f"Задача:\n{task.strip()}")
+    if code.strip():
+        parts.append(f"Решение (код):\n```python\n{code.strip()}\n```")
+    return "\n\n".join(parts)
+
+@app.post("/analyze", response_model=AnalysisResponse)
+async def analyze_code(request: AnalysisRequest):
+    """Анализирует код студента"""
+    if model is None or tokenizer is None:
+        raise HTTPException(status_code=503, detail="Модель еще не загружена")
+    
+    # Форматирование входа
+    input_text = build_input(request.task, request.code)
+    prompt = f"{input_text}\n\nОтвет:\n"
+    
+    # Генерация
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=600,
+            temperature=0.7,
+            top_p=0.85,
+            top_k=20,
+            repetition_penalty=1.05,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id
+        )
+    
+    # Декодирование и парсинг JSON
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    json_str = response.split("Ответ:")[-1].strip()
+    
+    try:
+        analysis = json.loads(json_str)
+        return AnalysisResponse(success=True, analysis=analysis)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=500, detail="Ошибка парсинга JSON")
+
+# Запуск: uvicorn main:app --host 0.0.0.0 --port 8000
+```
+
+### 2. Flask
+
+```python
+from flask import Flask, request, jsonify
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import json
+
+app = Flask(__name__)
+
+MODEL_NAME = "Vilyam888/Code_analyze.1.0"
+model = None
+tokenizer = None
+
+def load_model():
+    """Загружает модель"""
+    global model, tokenizer
+    if model is None:
+        print("Загрузка модели...")
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto",
+            trust_remote_code=True
+        )
+        print("Модель загружена!")
+
+def build_input(task, code):
+    parts = []
+    if task.strip():
+        parts.append(f"Задача:\n{task.strip()}")
+    if code.strip():
+        parts.append(f"Решение (код):\n```python\n{code.strip()}\n```")
+    return "\n\n".join(parts)
+
+@app.route('/analyze', methods=['POST'])
+def analyze():
+    """Анализирует код"""
+    load_model()
+    
+    data = request.json
+    task = data.get('task', '')
+    code = data.get('code', '')
+    
+    if not task or not code:
+        return jsonify({'error': 'task и code обязательны'}), 400
+    
+    # Генерация
+    input_text = build_input(task, code)
+    prompt = f"{input_text}\n\nОтвет:\n"
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+    
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=600,
+            temperature=0.7,
+            top_p=0.85,
+            top_k=20,
+            repetition_penalty=1.05,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id
+        )
+    
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    json_str = response.split("Ответ:")[-1].strip()
+    
+    try:
+        analysis = json.loads(json_str)
+        return jsonify({'success': True, 'analysis': analysis})
+    except json.JSONDecodeError:
+        return jsonify({'error': 'Ошибка парсинга JSON', 'raw': json_str}), 500
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=8000)
+```
+
+### 3. Django REST Framework
+
+```python
+# views.py
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import json
+
+MODEL_NAME = "Vilyam888/Code_analyze.1.0"
+model = None
+tokenizer = None
+
+def load_model():
+    global model, tokenizer
+    if model is None:
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto",
+            trust_remote_code=True
+        )
+
+class AnalyzeCodeView(APIView):
+    def post(self, request):
+        load_model()
+        
+        task = request.data.get('task', '')
+        code = request.data.get('code', '')
+        
+        if not task or not code:
+            return Response(
+                {'error': 'task и code обязательны'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Генерация анализа
+        input_text = f"Задача:\n{task}\n\nРешение (код):\n```python\n{code}\n```"
+        prompt = f"{input_text}\n\nОтвет:\n"
+        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_new_tokens=600,
+                temperature=0.7,
+                top_p=0.85,
+                top_k=20,
+                repetition_penalty=1.05,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id
+            )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        json_str = response.split("Ответ:")[-1].strip()
+        
+        try:
+            analysis = json.loads(json_str)
+            return Response({'success': True, 'analysis': analysis})
+        except json.JSONDecodeError:
+            return Response(
+                {'error': 'Ошибка парсинга JSON'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+```
+
+```python
+# urls.py
+from django.urls import path
+from .views import AnalyzeCodeView
+
+urlpatterns = [
+    path('api/analyze/', AnalyzeCodeView.as_view(), name='analyze'),
+]
+```
+
+---
+
+## Node.js / Express
+
+```javascript
+const express = require('express');
+const { PythonShell } = require('python-shell'); // или используйте child_process
+const app = express();
+
+app.use(express.json());
+
+// Вариант 1: Вызов Python скрипта через child_process
+const { spawn } = require('child_process');
+
+app.post('/analyze', async (req, res) => {
+    const { task, code } = req.body;
+    
+    if (!task || !code) {
+        return res.status(400).json({ error: 'task и code обязательны' });
+    }
+    
+    // Вызов Python скрипта
+    const python = spawn('python', ['analyze.py', JSON.stringify({ task, code })]);
+    let result = '';
+    
+    python.stdout.on('data', (data) => {
+        result += data.toString();
+    });
+    
+    python.on('close', (code) => {
+        if (code !== 0) {
+            return res.status(500).json({ error: 'Ошибка выполнения анализа' });
+        }
+        
+        try {
+            const analysis = JSON.parse(result);
+            res.json({ success: true, analysis });
+        } catch (e) {
+            res.status(500).json({ error: 'Ошибка парсинга JSON' });
+        }
+    });
+});
+
+// Вариант 2: Использование Hugging Face Inference API
+const axios = require('axios');
+
+app.post('/analyze', async (req, res) => {
+    const { task, code } = req.body;
+    
+    if (!task || !code) {
+        return res.status(400).json({ error: 'task и code обязательны' });
+    }
+    
+    const inputText = `Задача:\n${task}\n\nРешение (код):\n\`\`\`python\n${code}\n\`\`\``;
+    const prompt = `${inputText}\n\nОтвет:\n`;
+    
+    try {
+        const response = await axios.post(
+            'https://api-inference.huggingface.co/models/Vilyam888/Code_analyze.1.0',
+            {
+                inputs: prompt,
+                parameters: {
+                    max_new_tokens: 600,
+                    temperature: 0.7,
+                    top_p: 0.85,
+                    top_k: 20,
+                    repetition_penalty: 1.05
+                }
+            },
+            {
+                headers: {
+                    'Authorization': `Bearer ${process.env.HF_TOKEN}`
+                }
+            }
+        );
+        
+        const generatedText = response.data[0].generated_text;
+        const jsonStr = generatedText.split('Ответ:')[1]?.trim() || generatedText;
+        
+        try {
+            const analysis = JSON.parse(jsonStr);
+            res.json({ success: true, analysis });
+        } catch (e) {
+            res.status(500).json({ error: 'Ошибка парсинга JSON', raw: jsonStr });
+        }
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+app.listen(8000, () => {
+    console.log('Server running on port 8000');
+});
+```
+
+---
+
+## Использование как отдельный сервис (микросервис)
+
+### Docker контейнер
+
+```dockerfile
+# Dockerfile
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Установка зависимостей
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Копирование кода
+COPY . .
+
+# Запуск API сервера
+CMD ["uvicorn", "api_server:app", "--host", "0.0.0.0", "--port", "8000"]
+```
+
+```yaml
+# docker-compose.yml
+version: '3.8'
+
+services:
+  code-analyzer:
+    build: .
+    ports:
+      - "8000:8000"
+    environment:
+      - CUDA_VISIBLE_DEVICES=0  # Если есть GPU
+    volumes:
+      - ./models:/app/models
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]
+```
+
+### Вызов из другого сервиса
+
+```python
+# В вашем основном backend проекте
+import requests
+
+def analyze_student_code(task, code):
+    """Вызывает микросервис анализа кода"""
+    response = requests.post(
+        'http://code-analyzer:8000/analyze',  # или ваш URL
+        json={'task': task, 'code': code},
+        timeout=180  # 3 минуты для CPU
+    )
+    return response.json()
+
+# Использование
+result = analyze_student_code(
+    task="Напишите функцию для суммы списка",
+    code="def sum_list(numbers):\n    return sum(numbers)"
+)
+print(result['analysis'])
+```
+
+---
+
+## Кэширование результатов
+
+Для оптиционализации можно добавить кэширование:
+
+```python
+from functools import lru_cache
+import hashlib
+import json
+
+def get_cache_key(task, code):
+    """Генерирует ключ кэша"""
+    content = f"{task}|{code}"
+    return hashlib.md5(content.encode()).hexdigest()
+
+# Использование Redis для кэширования
+import redis
+
+redis_client = redis.Redis(host='localhost', port=6379, db=0)
+
+@app.post("/analyze")
+async def analyze_code(request: AnalysisRequest):
+    cache_key = get_cache_key(request.task, request.code)
+    
+    # Проверка кэша
+    cached = redis_client.get(cache_key)
+    if cached:
+        return json.loads(cached)
+    
+    # Генерация анализа
+    analysis = generate_analysis(request.task, request.code)
+    
+    # Сохранение в кэш (TTL 1 час)
+    redis_client.setex(cache_key, 3600, json.dumps(analysis))
+    
+    return analysis
+```
+
+---
+
+## Обработка ошибок и таймауты
+
+```python
+import asyncio
+from fastapi import HTTPException
+
+@app.post("/analyze")
+async def analyze_code(request: AnalysisRequest):
+    try:
+        # Таймаут 3 минуты
+        analysis = await asyncio.wait_for(
+            generate_analysis_async(request.task, request.code),
+            timeout=180.0
+        )
+        return analysis
+    except asyncio.TimeoutError:
+        raise HTTPException(
+            status_code=504,
+            detail="Анализ занял слишком много времени"
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Ошибка при анализе: {str(e)}"
+        )
+```
+
+---
+
+## Пример requirements.txt
+
+```txt
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+transformers==5.0.0
+torch==2.1.0
+accelerate==0.25.0
+sentencepiece==0.1.99
+pydantic==2.5.0
+```
+
+---
+
+## Рекомендации по развертыванию
+
+1. **GPU рекомендуется** - для быстрой работы (10-30 сек вместо 1-3 мин)
+2. **Кэширование** - для повторяющихся запросов
+3. **Очередь задач** - для обработки множественных запросов (Celery, RQ)
+4. **Мониторинг** - отслеживание времени ответа и ошибок
+5. **Rate limiting** - ограничение количества запросов
+
+---
+
+## Быстрый старт
+
+1. Установите зависимости:
+```bash
+pip install transformers torch fastapi uvicorn
+```
+
+2. Скопируйте код из примеров выше
+
+3. Запустите сервер:
+```bash
+uvicorn main:app --host 0.0.0.0 --port 8000
+```
+
+4. Протестируйте:
+```bash
+curl -X POST http://localhost:8000/analyze \
+  -H "Content-Type: application/json" \
+  -d '{"task": "Напишите функцию для суммы", "code": "def sum_list(numbers): return sum(numbers)"}'
+```
+
+---
+
+**Готово!** Теперь модель интегрирована в ваш backend проект.

ENABLE_INFERENCE_API.md

@@ -0,0 +1,100 @@
+# Как включить Inference API для модели
+
+Для того чтобы на странице модели появилась кнопка "Inference API", нужно выполнить следующие шаги:
+
+## Шаг 1: Проверьте настройки модели
+
+Убедитесь, что в `README.md` есть правильные метаданные:
+
+```yaml
+---
+library_name: transformers
+pipeline_tag: text-generation
+inference: true
+---
+```
+
+✅ Эти настройки уже есть в вашей модели!
+
+## Шаг 2: Убедитесь, что модель публичная
+
+1. Перейдите на страницу модели: https://huggingface.co/Vilyam888/Code_analyze.1.0
+2. Нажмите на иконку настроек (⚙️) в правом верхнем углу
+3. Выберите "Settings" → "Change visibility"
+4. Убедитесь, что выбрано **"Public"**
+5. Сохраните изменения
+
+## Шаг 3: Подождите активации
+
+После загрузки модели Inference API может активироваться автоматически, но это может занять:
+- **Несколько минут** для небольших моделей
+- **Несколько часов** для больших моделей (3B+ параметров)
+- **До 24 часов** в некоторых случаях
+
+## Шаг 4: Проверьте статус Inference API
+
+1. Перейдите на страницу модели
+2. Прокрутите вниз до раздела **"Hosted inference API"**
+3. Если API активен, вы увидите:
+   - Кнопку "Use this model" → "Inference"
+   - Виджет для тестирования
+   - Информацию об API endpoint
+
+## Шаг 5: Если Inference API не активируется автоматически
+
+Для моделей 3B+ параметров Inference API может быть недоступен бесплатно. В этом случае:
+
+### Вариант A: Запросить активацию (если доступно)
+
+1. Перейдите на https://huggingface.co/settings/billing
+2. Проверьте, есть ли у вас доступ к Inference API
+3. Если нет, может потребоваться подписка
+
+### Вариант B: Использовать Gradio Space (рекомендуется)
+
+Создайте Gradio Space с API endpoint - это работает всегда:
+
+1. Создайте Space: https://huggingface.co/spaces
+2. Загрузите `app.py` и `requirements.txt`
+3. Используйте API endpoint: `https://YOUR_SPACE.hf.space/api/predict`
+
+**Подробная инструкция:** См. `GRADIO_SPACE_INSTRUCTIONS.md`
+
+### Вариант C: Использовать модель локально
+
+Пользователи могут загрузить модель и использовать локально:
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+# См. примеры в API_USAGE.md
+```
+
+## Текущий статус
+
+Ваша модель уже настроена правильно:
+- ✅ `pipeline_tag: text-generation` - установлен
+- ✅ `inference: true` - включен
+- ✅ Widget примеры - добавлены
+- ✅ Публичная модель - должна быть
+
+## Что делать сейчас
+
+1. **Убедитесь, что модель публичная** (Settings → Change visibility → Public)
+2. **Загрузите обновленные файлы:**
+   ```bash
+   python scripts/upload_hf.py
+   ```
+3. **Подождите 1-24 часа** для активации Inference API
+4. **Проверьте страницу модели** - должна появиться кнопка "Inference"
+
+## Альтернатива: Gradio Space API
+
+Если Inference API недоступен, используйте Gradio Space с API endpoint - это работает сразу и не требует ожидания.
+
+**API Endpoint:** `https://YOUR_SPACE.hf.space/api/predict`
+
+**Документация:** См. `API_ENDPOINT.md`
+
+---
+
+**Примечание:** Для моделей размером 3B+ параметров Inference API может быть доступен только с подпиской или может не активироваться автоматически. В этом случае Gradio Space - лучшая альтернатива.

README.md

@@ -1,68 +1,269 @@
----
-library_name: transformers
-license: apache-2.0
-base_model: Qwen/Qwen2.5-Coder-3B-Instruct
-pipeline_tag: text-generation
-inference: true
-tags:
-- code
-- code-analysis
-- qwen
-- qwen2
-- text-generation
-- transformers
-- fine-tuned
-widget:
-- text: "Проанализируй этот код:\ndef hello():\n    print('Hello, World!')"
-  example_title: "Анализ простого кода"
-- text: "Объясни, что делает эта функция:\ndef factorial(n):\n    if n <= 1:\n        return 1\n    return n * factorial(n-1)"
-  example_title: "Объяснение функции"
----
-
-# Code Analyzer Model
-
-Fine-tuned версия модели Qwen2.5-Coder-3B-Instruct для анализа кода студента на основе условия задачи.
-
-## Описание модели
-
-Эта модель предназначена для анализа кода студента, нахождения слабых сильных сторон и выставления оценки. Модель принимает:
-- **Условие задачи** (текстовое описание)
-- **Код решения студента** (Python код)
-
-И возвращает детальный анализ в формате JSON, включающий:
-- Оценку правильности решения
-- Анализ соответствия требованиям задачи
-- Оценку качества кода
-- Сильные и слабые стороны решения
-- Рекомендации по улучшению
-- Детальный анализ с обоснованием
-
-Модель основана на Qwen2.5-Coder-3B-Instruct и дообучена с использованием LoRA (Low-Rank Adaptation).
-
-
-
-
-## Детали обучения
-
-- **Базовая модель:** Qwen/Qwen2.5-Coder-3B-Instruct
-- **Метод обучения:** LoRA (Low-Rank Adaptation)
-- **Параметры LoRA:**
-  - `r`: 16
-  - `lora_alpha`: 32
-  - `lora_dropout`: 0.05
-- **Фреймворк:** TRL (Transformer Reinforcement Learning)
-- **Формат данных:** JSONL с полями `input` и `output`
-
-## Ограничения
-
-- Модель обучена на русском языке для анализа кода
-- Может генерировать неточные или неполные ответы
-- Требует GPU для эффективной работы
-
-## Лицензия
-
-Apache 2.0
-
-## Авторы
-
-Fine-tuned by Vilyam888
+---
+library_name: transformers
+license: apache-2.0
+base_model: Qwen/Qwen2.5-Coder-3B-Instruct
+pipeline_tag: text-generation
+inference: true
+tags:
+- code
+- code-analysis
+- qwen
+- qwen2
+- text-generation
+- transformers
+- fine-tuned
+widget:
+- text: "Задача:\nНапишите функцию, которая принимает список чисел и возвращает сумму всех элементов.\n\nРешение (код):\n```python\ndef sum_list(numbers):\n    total = 0\n    for num in numbers:\n        total += num\n    return total\n```\n\nОтвет:\n"
+  example_title: "Анализ кода - сумма списка"
+- text: "Задача:\nСоздайте функцию для вычисления факториала числа.\n\nРешение (код):\n```python\ndef factorial(n):\n    if n <= 1:\n        return 1\n    return n * factorial(n-1)\n```\n\nОтвет:\n"
+  example_title: "Анализ кода - факториал"
+---
+
+# Code Analyzer Model
+
+Fine-tuned версия модели Qwen2.5-Coder-3B-Instruct для анализа кода студента на основе условия задачи.
+
+## Описание модели
+
+Эта модель была обучена на датасете ITOG для анализа кода студента. Модель принимает:
+- **Условие задачи** (текстовое описание)
+- **Код решения студента** (Python код)
+
+И возвращает детальный анализ в формате JSON, включающий:
+- Оценку правильности решения
+- Анализ соответствия требованиям задачи
+- Оценку качества кода
+- Сильные и слабые стороны решения
+- Рекомендации по улучшению
+- Детальный анализ с обоснованием
+
+Модель основана на Qwen2.5-Coder-3B-Instruct и дообучена с использованием LoRA (Low-Rank Adaptation).
+
+## Быстрый старт
+
+### Вариант 1: Использование Inference API (если доступен)
+
+1. Перейдите на страницу модели: https://huggingface.co/Vilyam888/Code_analyze.1.0
+2. Нажмите кнопку **"Use this model"** → **"Inference"**
+3. Или прокрутите вниз до раздела **"Hosted inference API"**
+4. Введите условие задачи и код студента в правильном формате
+5. Нажмите "Compute" для получения ответа
+
+**Примечание:** Если кнопка "Inference" не появляется, см. `ENABLE_INFERENCE_API.md` для инструкций по активации.
+
+### Вариант 1.5: Создайте Gradio Space (если Inference API недоступен)
+
+Если опция "Inference" не отображается в меню "Use this model", создайте интерактивный Gradio Space:
+
+**Быстрая инструкция:**
+
+1. Перейдите на https://huggingface.co/spaces
+2. Нажмите **"Create new Space"**
+3. Заполните форму:
+   - **Space name**: `code-analyzer-demo` (или любое другое)
+   - **SDK**: выберите **Gradio**
+   - **Hardware**: **CPU Basic** (бесплатно)
+   - **Visibility**: **Public**
+4. Нажмите **"Create Space"**
+5. Загрузите файлы:
+   - `app.py` (из этой модели)
+   - `requirements_gradio.txt` → переименуйте в `requirements.txt`
+6. Дождитесь автоматического запуска (2-5 минут)
+7. Готово! Интерфейс будет доступен на странице Space
+
+**Подробная инструкция:** См. файл `GRADIO_SPACE_INSTRUCTIONS.md` в корне проекта
+
+### Вариант 2: Использование локально (Python)
+
+**Установка зависимостей:**
+```bash
+pip install transformers torch
+```
+
+**Простой пример использования:**
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import json
+
+model_name = "Vilyam888/Code_analyze.1.0"
+
+# Загрузка модели
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype=torch.bfloat16,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+# Условие задачи
+task = "Напишите функцию, которая принимает список чисел и возвращает сумму всех элементов."
+
+# Код студента
+code = """def sum_list(numbers):
+    total = 0
+    for num in numbers:
+        total += num
+    return total"""
+
+# Форматирование входа
+input_text = f"Задача:\n{task}\n\nРешение (код):\n```python\n{code}\n```"
+prompt = f"{input_text}\n\nОтвет:\n"
+
+# Генерация анализа
+inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+with torch.no_grad():
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=1024,
+        temperature=0.7,
+        top_p=0.8,
+        top_k=20,
+        repetition_penalty=1.05,
+        do_sample=True
+    )
+
+# Декодирование и парсинг JSON
+response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+result = response.split("Ответ:")[-1].strip()
+analysis = json.loads(result)
+
+print(json.dumps(analysis, ensure_ascii=False, indent=2))
+```
+
+**Или используйте готовые скрипты из репозитория:**
+
+Простой пример (минимальный код):
+```bash
+python scripts/quick_start_example.py
+```
+
+Полный пример с интерактивным режимом:
+```bash
+python scripts/use_model_example.py
+```
+
+## Использование
+
+### С помощью transformers
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+model_name = "Vilyam888/Code_analyze.1.0"
+
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype=torch.bfloat16,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+# Формат запроса
+prompt = "Проанализируй этот код:\ndef hello():\n    print('Hello, World!')"
+
+# Форматирование в стиле обучения
+text = f"{prompt}\n\nОтвет:\n"
+
+inputs = tokenizer(text, return_tensors="pt").to(model.device)
+
+with torch.no_grad():
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=512,
+        temperature=0.7,
+        top_p=0.8,
+        top_k=20,
+        repetition_penalty=1.05,
+        do_sample=True
+    )
+
+response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+print(response)
+```
+
+### С помощью pipeline
+
+```python
+from transformers import pipeline
+
+model_name = "Vilyam888/Code_analyze.1.0"
+
+generator = pipeline(
+    "text-generation",
+    model=model_name,
+    tokenizer=model_name,
+    trust_remote_code=True,
+    device_map="auto"
+)
+
+prompt = "Объясни, что делает этот код:\ndef factorial(n):\n    if n <= 1:\n        return 1\n    return n * factorial(n-1)"
+text = f"{prompt}\n\nОтвет:\n"
+
+result = generator(
+    text,
+    max_new_tokens=512,
+    temperature=0.7,
+    top_p=0.8,
+    top_k=20,
+    repetition_penalty=1.05,
+    do_sample=True
+)
+
+print(result[0]["generated_text"])
+```
+
+## Детали обучения
+
+- **Базовая модель:** Qwen/Qwen2.5-Coder-3B-Instruct
+- **Метод обучения:** LoRA (Low-Rank Adaptation)
+- **Параметры LoRA:**
+  - `r`: 16
+  - `lora_alpha`: 32
+  - `lora_dropout`: 0.05
+- **Фреймворк:** TRL (Transformer Reinforcement Learning)
+- **Формат данных:** JSONL с полями `input` и `output`
+
+## Ограничения
+
+- Модель обучена на русском языке для анализа кода
+- Может генерировать неточные или неполные ответы
+- Требует GPU для эффективной работы
+
+## Использование через API
+
+Модель можно использовать через несколько способов:
+
+### 1. Через transformers (Python)
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+# См. полные примеры в API_USAGE.md
+```
+
+### 2. Через Hugging Face Inference API
+```python
+import requests
+API_URL = "https://api-inference.huggingface.co/models/Vilyam888/Code_analyze.1.0"
+# См. полные примеры в API_USAGE.md
+```
+
+### 3. Через Gradio Space API
+Если создан Gradio Space, можно использовать его API endpoint.
+
+### 4. Интеграция в Backend проект
+Примеры для FastAPI, Flask, Django, Node.js и других фреймворков.
+
+**Подробная документация:**
+- `API_USAGE.md` - использование через Hugging Face API
+- `BACKEND_INTEGRATION.md` - интеграция в backend проекты
+
+## Лицензия
+
+Apache 2.0
+
+## Авторы
+
+Fine-tuned by Vilyam888

README_SPACE.md

@@ -0,0 +1,27 @@
+# Как создать Gradio Space для интерактивного использования
+
+Если опция "Inference" не появляется в меню "Use this model", создайте Gradio Space:
+
+## Шаг 1: Создайте новый Space на Hugging Face
+
+1. Перейдите на https://huggingface.co/spaces
+2. Нажмите "Create new Space"
+3. Заполните:
+   - **Space name**: `code-analyzer-demo` (или любое другое имя)
+   - **SDK**: выберите **Gradio**
+   - **Hardware**: выберите **CPU Basic** (бесплатно) или **GPU** (если доступно)
+   - **Visibility**: Public
+
+## Шаг 2: Загрузите файлы
+
+Загрузите в Space следующие файлы:
+- `app.py` (из этой папки)
+- `requirements_gradio.txt` (переименуйте в `requirements.txt`)
+
+## Шаг 3: Дождитесь запуска
+
+Space автоматически запустится и создаст интерактивный интерфейс для вашей модели!
+
+## Альтернатива: Используйте виджет на странице модели
+
+На странице модели должен быть виджет внизу страницы, даже если опция "Inference" не в меню.

app.py

@@ -1,176 +1,187 @@
-"""
-Gradio Space для интерактивного использования модели Code Analyzer
-Модель анализирует код студента на основе условия задачи
-"""
-import gradio as gr
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import torch
-import json
-
-# Загрузка модели (будет выполнена при первом запуске)
-MODEL_NAME = "Vilyam888/Code_analyze.1.0"
-
-def load_model():
-    """Загружает модель один раз при старте и сохраняет в глобальные переменные"""
-    global model, tokenizer
-    
-    if model is None or tokenizer is None:
-        print("Загрузка модели...")
-        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
-        model = AutoModelForCausalLM.from_pretrained(
-            MODEL_NAME,
-            torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
-            device_map="auto",
-            trust_remote_code=True
-        )
-        print("Модель загружена успешно!")
-
-# Глобальные переменные для модели
-model, tokenizer = None, None
-
-def build_input(task, code):
-    """Форматирует вход в том же формате, что использовался при обучении"""
-    parts = []
-    if task.strip():
-        parts.append(f"Задача:\n{task.strip()}")
-    if code.strip():
-        parts.append(f"Решение (код):\n```python\n{code.strip()}\n```")
-    return "\n\n".join(parts)
-
-def analyze_code(task, code):
-    """Анализирует код студента и возвращает результат в формате JSON"""
-    global model, tokenizer
-    
-    if model is None or tokenizer is None:
-        return "⏳ Загрузка модели... Пожалуйста, подождите."
-    
-    if not task.strip():
-        return "❌ Пожалуйста, введите условие задачи."
-    
-    if not code.strip():
-        return "❌ Пожалуйста, введите код решения студента."
-    
-    try:
-        # Форматирование входа в стиле обучения
-        input_text = build_input(task, code)
-        prompt = f"{input_text}\n\nОтвет:\n"
-        
-        # Токенизация
-        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
-        
-        # Генерация ответа
-        with torch.no_grad():
-            outputs = model.generate(
-                **inputs,
-                max_new_tokens=1024,  # Увеличено для JSON ответа
-                temperature=0.7,
-                top_p=0.8,
-                top_k=20,
-                repetition_penalty=1.05,
-                do_sample=True,
-                pad_token_id=tokenizer.eos_token_id
-            )
-        
-        # Декодирование ответа
-        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        
-        # Извлечение JSON ответа
-        if "Ответ:" in response:
-            json_str = response.split("Ответ:")[-1].strip()
-        else:
-            json_str = response
-        
-        # Попытка распарсить JSON
-        try:
-            result = json.loads(json_str)
-            # Форматируем JSON для красивого отображения
-            return json.dumps(result, ensure_ascii=False, indent=2)
-        except json.JSONDecodeError:
-            # Если не JSON, возвращаем как есть
-            return json_str
-        
-    except Exception as e:
-        return f"❌ Ошибка: {str(e)}"
-
-# Создание Gradio интерфейса
-with gr.Blocks(title="Code Analyzer Model") as demo:
-    gr.Markdown("""
-    # 🔍 Code Analyzer Model
-    
-    Модель для анализа кода студента на основе условия задачи.
-    
-    **Как использовать:**
-    1. Введите условие задачи в первое поле
-    2. Введите код решения студента во второе поле
-    3. Нажмите "Анализировать код"
-    4. Получите детальный анализ в формате JSON
-    """)
-    
-    with gr.Row():
-        with gr.Column():
-            task_input = gr.Textbox(
-                label="Условие задачи",
-                placeholder="Введите условие задачи...",
-                lines=5
-            )
-            code_input = gr.Textbox(
-                label="Код решения студента",
-                placeholder="Введите код решения...",
-                lines=10
-            )
-            submit_btn = gr.Button("Анализировать код", variant="primary", size="lg")
-        
-        with gr.Column():
-            result_output = gr.JSON(
-                label="Результат анализа"
-            )
-            # Также показываем как текст для удобства копирования
-            result_text = gr.Textbox(
-                label="Результат (JSON текст)",
-                lines=15,
-                interactive=False
-            )
-    
-    # Примеры
-    gr.Examples(
-        examples=[
-            [
-                "Напишите функцию, которая принимает список чисел и возвращает сумму всех элементов.",
-                "def sum_list(numbers):\n    total = 0\n    for num in numbers:\n        total += num\n    return total"
-            ],
-            [
-                "Создайте функцию для вычисления факториала числа.",
-                "def factorial(n):\n    if n <= 1:\n        return 1\n    return n * factorial(n-1)"
-            ],
-        ],
-        inputs=[task_input, code_input]
-    )
-    
-    def analyze_and_format(task, code):
-        """Анализирует код и форматирует результат"""
-        result_str = analyze_code(task, code)
-        try:
-            result_json = json.loads(result_str)
-            return result_json, result_str
-        except:
-            return None, result_str
-    
-    # Загрузка модели при старте
-    demo.load(load_model, outputs=None)
-    
-    # Обработчик кнопки
-    submit_btn.click(
-        fn=analyze_and_format,
-        inputs=[task_input, code_input],
-        outputs=[result_output, result_text]
-    )
-    
-    # Обработчик Enter в поле кода
-    code_input.submit(
-        fn=analyze_and_format,
-        inputs=[task_input, code_input],
-        outputs=[result_output, result_text]
-    )
-
-if __name__ == "__main__":
-    demo.launch(theme=gr.themes.Soft())
+"""
+Gradio Space для интерактивного использования модели Code Analyzer
+Модель анализирует код студента на основе условия задачи
+Поддерживает как веб-интерфейс, так и API endpoint
+"""
+import gradio as gr
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import json
+from pydantic import BaseModel
+from typing import Optional
+
+# Загрузка модели (будет выполнена при первом запуске)
+MODEL_NAME = "Vilyam888/Code_analyze.1.0"
+
+def load_model():
+    """Загружает модель один раз при старте и сохраняет в глобальные переменные"""
+    global model, tokenizer
+    
+    if model is None or tokenizer is None:
+        print("Загрузка модели...")
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto",
+            trust_remote_code=True
+        )
+        print("Модель загружена успешно!")
+
+# Глобальные переменные для модели
+model, tokenizer = None, None
+
+def build_input(task, code):
+    """Форматирует вход в том же формате, что использовался при обучении"""
+    parts = []
+    if task.strip():
+        parts.append(f"Задача:\n{task.strip()}")
+    if code.strip():
+        parts.append(f"Решение (код):\n```python\n{code.strip()}\n```")
+    return "\n\n".join(parts)
+
+def analyze_code(task, code):
+    """Анализирует код студента и возвращает результат в формате JSON"""
+    global model, tokenizer
+    
+    if model is None or tokenizer is None:
+        return "⏳ Загрузка модели... Пожалуйста, подождите."
+    
+    if not task.strip():
+        return "❌ Пожалуйста, введите условие задачи."
+    
+    if not code.strip():
+        return "❌ Пожалуйста, введите код решения студента."
+    
+    try:
+        # Форматирование входа в стиле обучения
+        input_text = build_input(task, code)
+        prompt = f"{input_text}\n\nОтвет:\n"
+        
+        # Токенизация
+        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+        
+        # Генерация ответа
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_new_tokens=600,  # Оптимизировано для CPU
+                temperature=0.7,
+                top_p=0.85,
+                top_k=20,
+                repetition_penalty=1.05,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id
+            )
+        
+        # Декодирование ответа
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Извлечение JSON ответа
+        if "Ответ:" in response:
+            json_str = response.split("Ответ:")[-1].strip()
+        else:
+            json_str = response
+        
+        # Попытка распарсить JSON
+        try:
+            result = json.loads(json_str)
+            # Форматируем JSON для красивого отображения
+            return json.dumps(result, ensure_ascii=False, indent=2)
+        except json.JSONDecodeError:
+            # Если не JSON, возвращаем как есть
+            return json_str
+        
+    except Exception as e:
+        return f"❌ Ошибка: {str(e)}"
+
+# Создание Gradio интерфейса
+with gr.Blocks(title="Code Analyzer Model") as demo:
+    gr.Markdown("""
+    # 🔍 Code Analyzer Model
+    
+    Модель для анализа кода студента на основе условия задачи.
+    
+    **Как использовать:**
+    1. Введите условие задачи в первое поле
+    2. Введите код решения студента во второе поле
+    3. Нажмите "Анализировать код"
+    4. Получите детальный анализ в формате JSON
+    
+    **API Endpoint:** `/api/predict` - используйте для интеграции в другие проекты
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            task_input = gr.Textbox(
+                label="Условие задачи",
+                placeholder="Введите условие задачи...",
+                lines=5
+            )
+            code_input = gr.Textbox(
+                label="Код решения студента",
+                placeholder="Введите код решения...",
+                lines=10
+            )
+            submit_btn = gr.Button("Анализировать код", variant="primary", size="lg")
+        
+        with gr.Column():
+            result_output = gr.JSON(
+                label="Результат анализа"
+            )
+            # Также показываем как текст для удобства копирования
+            result_text = gr.Textbox(
+                label="Результат (JSON текст)",
+                lines=15,
+                interactive=False
+            )
+    
+    # Примеры
+    gr.Examples(
+        examples=[
+            [
+                "Напишите функцию, которая принимает список чисел и возвращает сумму всех элементов.",
+                "def sum_list(numbers):\n    total = 0\n    for num in numbers:\n        total += num\n    return total"
+            ],
+            [
+                "Создайте функцию для вычисления факториала числа.",
+                "def factorial(n):\n    if n <= 1:\n        return 1\n    return n * factorial(n-1)"
+            ],
+        ],
+        inputs=[task_input, code_input]
+    )
+    
+    def analyze_and_format(task, code):
+        """Анализирует код и форматирует результат"""
+        result_str = analyze_code(task, code)
+        try:
+            result_json = json.loads(result_str)
+            return result_json, result_str
+        except:
+            return None, result_str
+    
+    # Загрузка модели при старте
+    demo.load(load_model, outputs=None)
+    
+    # Обработчик кнопки
+    submit_btn.click(
+        fn=analyze_and_format,
+        inputs=[task_input, code_input],
+        outputs=[result_output, result_text]
+    )
+    
+    # Обработчик Enter в поле кода
+    code_input.submit(
+        fn=analyze_and_format,
+        inputs=[task_input, code_input],
+        outputs=[result_output, result_text]
+    )
+
+# Gradio автоматически создает API endpoint на /api/predict
+# Для использования из других проектов:
+# POST https://YOUR_SPACE_URL.hf.space/api/predict
+# Body: {"data": ["task", "code"]}
+
+if __name__ == "__main__":
+    demo.launch(theme=gr.themes.Soft(), server_name="0.0.0.0")

requirements_gradio.txt

@@ -3,3 +3,5 @@ transformers>=5.0.0
 torch>=2.0.0
 accelerate
 sentencepiece
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0