Spaces:
Sleeping
Sleeping
File size: 5,994 Bytes
17e49b6 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 |
import aiohttp
import asyncio
import json
import logging
from typing import List, Dict, Any
from fallback_questions import FallbackQuestions
logger = logging.getLogger(__name__)
class QuizGenerator:
def __init__(self, api_key: str):
self.api_key = api_key
self.model_used = "fallback"
self.generation_method = "fallback"
self.fallback = FallbackQuestions()
# Modell-konfigurasjon
self.models = {
"norwegian": "NbAiLab/nb-gpt-j-6B",
"english": "meta-llama/Llama-2-70b-chat-hf",
"fallback": "google/flan-t5-small"
}
async def generate_quiz(self, request) -> List[Dict[str, Any]]:
"""Hovedmetode for quiz-generering"""
logger.info(f"Starter quiz-generering: {request.tema} ({request.språk})")
# Prøv AI-generering først
if self.api_key:
try:
questions = await self._try_ai_generation(request)
if questions:
logger.info(f"AI-generering suksess: {len(questions)} spørsmål")
return questions
except Exception as e:
logger.warning(f"AI-generering feilet: {e}")
# Fallback til forhåndsdefinerte spørsmål
logger.info("Bruker fallback-spørsmål")
self.model_used = "fallback"
self.generation_method = "predefined"
return self.fallback.get_questions(
tema=request.tema,
språk=request.språk,
antall=request.antall_spørsmål,
type=request.type,
vanskelighet=request.vanskelighetsgrad
)
async def _try_ai_generation(self, request) -> List[Dict[str, Any]]:
"""Prøv AI-generering med forskjellige modeller"""
# Velg modell basert på språk
if request.språk == "no":
model = self.models["norwegian"]
else:
model = self.models["english"]
logger.info(f"Prøver AI-modell: {model}")
try:
questions = await self._call_huggingface_api(model, request)
if questions:
self.model_used = model
self.generation_method = "ai"
return questions
except Exception as e:
logger.warning(f"Modell {model} feilet: {e}")
# Prøv fallback-modell
try:
logger.info(f"Prøver fallback-modell: {self.models['fallback']}")
questions = await self._call_huggingface_api(self.models["fallback"], request)
if questions:
self.model_used = self.models["fallback"]
self.generation_method = "ai_fallback"
return questions
except Exception as e:
logger.warning(f"Fallback-modell feilet: {e}")
return []
async def _call_huggingface_api(self, model: str, request) -> List[Dict[str, Any]]:
"""Kall Hugging Face Inference API"""
prompt = self._build_prompt(request, model)
async with aiohttp.ClientSession() as session:
async with session.post(
f"https://api-inference.huggingface.co/models/{model}",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json={
"inputs": prompt,
"parameters": {
"max_new_tokens": 1500,
"temperature": 0.7,
"do_sample": True,
"top_p": 0.9
}
},
timeout=aiohttp.ClientTimeout(total=30)
) as response:
if response.status != 200:
error_text = await response.text()
raise Exception(f"HTTP {response.status}: {error_text}")
data = await response.json()
# Parse response
if isinstance(data, list) and data:
generated_text = data[0].get("generated_text", "")
elif isinstance(data, dict):
generated_text = data.get("generated_text", "")
else:
raise Exception("Uventet response-format")
# Parse quiz fra generert tekst
questions = self._parse_quiz_response(generated_text, request.antall_spørsmål)
if not questions:
raise Exception("Kunne ikke parse quiz-spørsmål fra AI-respons")
return questions
def _build_prompt(self, request, model: str) -> str:
"""Bygg prompt for AI-modell"""
if request.språk == "no":
return f"""Generer {request.antall_spørsmål} quiz-spørsmål på norsk om temaet "{request.tema}".
Format for hvert spørsmål:
SPØRSMÅL: [spørsmålstekst]
A) [alternativ 1]
B) [alternativ 2]
C) [alternativ 3]
D) [alternativ 4]
KORREKT: [A, B, C eller D]
FORKLARING: [kort forklaring]
---
Tema: {request.tema}
Type: {request.type}
Vanskelighetsgrad: {request.vanskelighetsgrad}/5
Start generering:"""
else:
return f"""Generate {request.antall_spørsmål} quiz questions in English about "{request.tema}".
Format each question exactly like this:
QUESTION: [question text]
A) [option 1]
B) [option 2]
C) [option 3]
D) [option 4]
CORRECT: [A, B, C, or D]
EXPLANATION: [brief explanation]
---
Topic: {request.tema}
Type: {request.type}
Difficulty: {request.vanskelighetsgrad}/5
Start generating:"""
def _parse_quiz_response(self, response: str, expected_count: int) -> List[Dict[str, Any]]:
"""Parse AI-respons til quiz-spørsmål"""
questions = []
# Spli |