Spaces:
Runtime error
Runtime error
Download app_old3.py from MatDyskretna/MatD: direct link, hf CLI and curl.
- Browser
- Download file 10.7 kB
-
https://huggingface.co/spaces/MatDyskretna/MatD/resolve/main/app_old3.py
- Command line
-
hf download hf://spaces/MatDyskretna/MatD/app_old3.py
-
curl -L -o app_old3.py https://huggingface.co/spaces/MatDyskretna/MatD/resolve/main/app_old3.py
10.7 kB
| import json, gradio as gr | |
| from rapidfuzz import fuzz, process | |
| import sympy as sp | |
| import re | |
| # --- Wczytaj bazę wiedzy --- | |
| DATA = json.load(open("knowledge.json", "r", encoding="utf-8")) | |
| def pretty_factorial(expr): | |
| """Zamienia gamma(x) → (x-1)! w dowolnym kontekście.""" | |
| expr_str = str(expr) | |
| # regex dopasowujący np. gamma(n), gamma(n+1), gamma(k-1) | |
| pattern = r"gamma\(([^)]+)\)" | |
| def repl(match): | |
| inner = match.group(1).strip() | |
| return f"({inner}-1)!" | |
| expr_str = re.sub(pattern, repl, expr_str) | |
| return expr_str | |
| def parse_recurrence_equation(equation_text): | |
| """ | |
| Analizuje rekurencję w postaci: | |
| a_0*T_0 = c_0 | |
| a_n*T_n = b_n*T_{n-1} + c_n | |
| Zwraca: a_0, a_n, b_n, c_n, c_0, initials | |
| """ | |
| import re, sympy as sp | |
| # Naprawiamy brak separatora między warunkiem początkowym a równaniem | |
| equation_text = re.sub(r"(T_0\s*=\s*[0-9\+\-\*/\^\(\)n]+)\s+(?=[0-9]+\*?T_n)", r"\1; ", equation_text) | |
| equation_text = equation_text.replace("^", "**") | |
| equation_text = re.sub(r"\s+", " ", equation_text.strip()) | |
| n = sp.Symbol("n") | |
| T = sp.Function("T") | |
| print("=== RAW INPUT ===") | |
| print(equation_text) | |
| # Znajdujemy równanie główne (a_n*T_n = b_n*T_{n-1} + c_n) | |
| match_eq = re.search(r"([0-9\*\^\+\-\sT_n\{\}\(\)n]+=[^=]+)$", equation_text) | |
| if not match_eq: | |
| raise ValueError("Nie udało się rozpoznać równania rekurencji w treści.") | |
| eq_part = match_eq.group(1) | |
| expr_text = eq_part.replace("T_{n-1}", "T(n-1)").replace("T_n", "T(n)") | |
| lhs_str, rhs_str = expr_text.split("=") | |
| lhs = sp.sympify(lhs_str) | |
| rhs = sp.sympify(rhs_str) | |
| a_n = lhs.expand().coeff(T(n)) or 1 | |
| b_n = rhs.expand().coeff(T(n-1)) or 0 | |
| c_n = sp.simplify(rhs - b_n*T(n-1)) | |
| # --- Warunki początkowe --- (T_0=1, 2*T_0=5, itp.) | |
| initials = re.findall(r"([0-9\*\^\+\-\s]*)T_([0-9]+)\s*=\s*([0-9\+\-\*/\^\(\)n]+)", equation_text) | |
| a_0 = sp.Integer(1) | |
| c_0 = None | |
| inits = [] | |
| for coeff_str, idx_str, val_str in initials: | |
| idx = int(idx_str) | |
| val = sp.sympify(val_str) | |
| coeff_str = coeff_str.strip() | |
| if idx == 0: | |
| a_0 = sp.sympify(coeff_str) if coeff_str else sp.Integer(1) | |
| c_0 = val | |
| inits.append((idx, val)) | |
| # --- Obliczenie T_0 --- | |
| if c_0 is not None: | |
| try: | |
| T_0 = sp.simplify(c_0 / a_0) | |
| except Exception: | |
| T_0 = None | |
| else: | |
| T_0 = None | |
| #obliczenie b_1 | |
| try: | |
| n = sp.Symbol("n") | |
| b1 = sp.simplify(sp.sympify(str(b_n)).subs(n, 1)) | |
| except Exception: | |
| b1 = "?" | |
| #żeby sam obliczył i uprościł S_n dla odczytanych współczynników | |
| try: | |
| n = sp.Symbol("n", integer=True, positive=True) | |
| i = sp.Symbol("i", integer=True, positive=True) | |
| # a_n, b_n muszą być sympy | |
| a_i_sub = a_n.subs(n, i) | |
| b_i_sub = b_n.subs(n, i) | |
| # --- NAJWAŻNIEJSZY PATCH --- | |
| # SymPy źle upraszcza (n-1)! do n**(n-1) w pewnych ścieżkach. | |
| # Dlatego NA SIŁĘ obsługujemy poprawnie najczęstszy przypadek. | |
| if sp.simplify(b_i_sub - 1) == 0 and sp.simplify(a_i_sub - i) == 0: | |
| # Czyli a_n = n oraz b_n = 1 | |
| # Wtedy S_n = a_0 * (n-1)! | |
| S_n_expr = a_0 * sp.factorial(n - 1) | |
| S_n = pretty_factorial(str(S_n_expr)) | |
| else: | |
| # Ogólny przypadek | |
| prod_a = sp.Product(a_i_sub, (i, 1, n - 1)) | |
| prod_b = sp.Product(b_i_sub, (i, 1, n)) | |
| S_n_expr = (a_0 * prod_a) / prod_b | |
| S_n_simpl = sp.simplify(S_n_expr) | |
| S_n = S_n_simpl | |
| except Exception as e: | |
| S_n = "?" | |
| print("a_0:", a_0, " a_n:", a_n, "b_n:", b_n," c_n:", c_n," c_0:", c_0," T_0:", T_0) | |
| print("DEBUG S_n sympy:", S_n) | |
| return { | |
| "a_0": pretty_factorial(a_0), | |
| "a_n": pretty_factorial(a_n), | |
| "b_n": pretty_factorial(b_n), | |
| "c_n": pretty_factorial(c_n), | |
| "b_1": pretty_factorial(str(b1)), | |
| "S_n": pretty_factorial(str(S_n)), | |
| "c_0": c_0, | |
| "T_0": T_0, # <-- dodane | |
| "initials": inits | |
| } | |
| # --- Dopasowanie podobnych zadań --- | |
| def find_similar(query, top_k=3): | |
| corpus = [(i, d["statement"] + " | " + d.get("topic", "") + " | " + d.get("group_id", "")) | |
| for i, d in enumerate(DATA)] | |
| choices = [c[1] for c in corpus] | |
| results = process.extract(query, choices, scorer=fuzz.token_set_ratio, limit=top_k) | |
| return [DATA[corpus[r[2]][0]] for r in results] | |
| # --- Tryb wskazówek --- | |
| def hint_mode(user_problem, step_idx=0): | |
| try: | |
| coeffs = parse_recurrence_equation(user_problem) | |
| for k, v in coeffs.items(): | |
| if hasattr(v, "__str__"): | |
| coeffs[k] = str(v) | |
| except Exception: | |
| coeffs = {"a_0": "?", "a_n": "?", "b_n": "?", "c_n": "?", "c_0": "?", "initials": []} | |
| hits = find_similar(user_problem, top_k=1) | |
| if not hits: | |
| return "Nie znalazłam podobnego zadania. Spróbuj dodać więcej kontekstu.", step_idx, coeffs | |
| z = hits[0] | |
| sol = z.get("solution", {}) | |
| tips = sol.get("tips", []) | |
| total = len(tips) | |
| if not tips: | |
| return "Brak wskazówek w bazie.", step_idx, coeffs | |
| if step_idx >= total: | |
| return "🎓 To już ostatnia wskazówka.", step_idx, coeffs | |
| tip = tips[step_idx] | |
| msg = f"**Wskazówka {step_idx+1}/{total}** (na podstawie *{z['title']}*):\n\n➡️ {tip}" | |
| #msg = f"**Wskazówka {step_idx+1}/{total}** (na podstawie *{z['title']}*):\n\n$$ {tip} $$" | |
| return msg, step_idx, coeffs | |
| # --- Pokaż realizację wskazówki --- | |
| def show_solution(user_problem, step_idx, coeffs): | |
| hits = find_similar(user_problem, top_k=1) | |
| if not hits: | |
| return "Nie znaleziono zadania." | |
| z = hits[0] | |
| sol = z.get("solution", {}) | |
| tips_solutions = sol.get("tips_solutions", []) | |
| if step_idx >= len(tips_solutions): | |
| return "Brak rozwiązania dla tej wskazówki." | |
| tip_sol_template = tips_solutions[step_idx] | |
| # Konwertujemy wszystkie wartości na string | |
| coeffs_for_format = {k: str(v) for k, v in coeffs.items()} | |
| #Rozwiązanie: użycie string.Formatter z bezpiecznym fallback-Python pozwala nadpisać zachowanie format_map() używając własnej klasy, | |
| #która zwraca oryginalny tekst dla nieznanych kluczy: | |
| # Klasa SafeDict zostawia nieznane placeholdery w szablonie | |
| #class SafeDict(dict): | |
| # def __missing__(self, key): | |
| # return "{" + key + "}" | |
| class SafeDict(dict): | |
| def __missing__(self, key): | |
| # pozostaw latexowe indeksy i podobne konstrukcje nietknięte | |
| if "=" in key or not key.isidentifier(): | |
| return "{" + key + "}" | |
| return "{" + key + "}" | |
| try: | |
| # <-- kluczowa zmiana: używamy format_map z SafeDict | |
| tip_sol = tip_sol_template.format_map(SafeDict(coeffs_for_format)) | |
| except Exception: | |
| tip_sol = tip_sol_template | |
| #try: | |
| # tip_sol = tip_sol_template.format(**coeffs_for_format) | |
| # except KeyError as e: | |
| # tip_sol = f"Nie udało się podstawić zmiennej: {e}" | |
| #except Exception: | |
| # tip_sol = tip_sol_template | |
| #return f"🧩 **Realizacja wskazówki {step_idx+1}:**\n\n{tip_sol}" | |
| latex_text = f"🧩 **Realizacja wskazówki {step_idx+1}:**\n\n$$ {tip_sol} $$" | |
| return latex_text | |
| # --- Tryb weryfikacji --- | |
| def verify_mode(user_problem, user_answer): | |
| hits = find_similar(user_problem, top_k=1) | |
| if not hits: | |
| return "Nie znalazłam podobnego zadania." | |
| z = hits[0] | |
| gold = z.get("solution", {}).get("final", "") | |
| if not gold: | |
| return "Brak wzorcowej odpowiedzi." | |
| try: | |
| x, n = sp.symbols("x n") | |
| ue = sp.simplify(sp.sympify(user_answer)) | |
| ge = sp.simplify(sp.sympify(gold)) | |
| ok = sp.simplify(ue - ge) == 0 | |
| verdict = "✅ Wynik zgodny z rozwiązaniem wzorcowym." if ok else "❌ Wynik różni się od wzorca." | |
| return f"**Weryfikacja** ({z['title']}):\n\n{verdict}" | |
| except Exception as e: | |
| return f"Nie udało się porównać wyrażeń: {e}" | |
| # --- Interfejs Gradio --- | |
| with gr.Blocks() as demo: | |
| gr.Markdown("# 🤖 AI-TutorMD — interaktywny tryb wskazówek (z resetem)") | |
| gr.Markdown("Podaj rekurencję i przechodź krok po kroku. Przy zmianie zadania rozmowa się resetuje.") | |
| chatbot = gr.Chatbot(label="Rozmowa z AI-Tutorem", height=400) | |
| inp = gr.Textbox(label="Treść zadania", placeholder="np. T_0=1 4*T_n = 5*T_{n-1} + 2**n") | |
| ans = gr.Textbox(label="Twój wynik", placeholder="np. (5**n - 1)/4") | |
| step_state = gr.State(0) | |
| coeffs_state = gr.State({}) | |
| history_state = gr.State([]) | |
| with gr.Row(): | |
| btn_first = gr.Button("🧩 Pierwsza wskazówka") | |
| btn_next = gr.Button("➡️ Kolejna wskazówka") | |
| btn_show = gr.Button("👁 Pokaż realizację wskazówki") | |
| btn_verify = gr.Button("🔍 Weryfikuj wynik") | |
| # --- Logika przycisków --- | |
| def first_hint(user_problem, history): | |
| msg, step_idx, coeffs = hint_mode(user_problem, 0) | |
| history.append((user_problem, msg)) | |
| return history, step_idx, coeffs | |
| def next_hint(user_problem, history, step_idx): | |
| msg, new_idx, coeffs = hint_mode(user_problem, step_idx + 1) | |
| history.append(("➡️ Kolejna wskazówka", msg)) | |
| return history, new_idx, coeffs | |
| def show_current_solution(user_problem, history, step_idx, coeffs): | |
| msg = show_solution(user_problem, step_idx, coeffs) | |
| history.append(("👁 Pokaż realizację wskazówki", msg)) | |
| return history | |
| def verify(user_problem, user_answer, history): | |
| msg = verify_mode(user_problem, user_answer) | |
| history.append((f"🧮 {user_problem} = {user_answer}", msg)) | |
| return history | |
| # --- RESET przy zmianie treści zadania --- | |
| def reset_session(_): | |
| return [], 0, {} | |
| inp.change(fn=reset_session, inputs=inp, | |
| outputs=[chatbot, step_state, coeffs_state]) | |
| # --- Podpięcie przycisków --- | |
| btn_first.click(first_hint, inputs=[inp, history_state], | |
| outputs=[chatbot, step_state, coeffs_state]) | |
| btn_next.click(next_hint, inputs=[inp, chatbot, step_state], | |
| outputs=[chatbot, step_state, coeffs_state]) | |
| btn_show.click(show_current_solution, inputs=[inp, chatbot, step_state, coeffs_state], | |
| outputs=chatbot) | |
| btn_verify.click(verify, inputs=[inp, ans, chatbot], outputs=chatbot) | |
| gr.Markdown("---\n💡 Zmiana treści zadania automatycznie resetuje rozmowę i licznik kroków.") | |
| demo.launch() | |