File size: 6,022 Bytes
40d4065
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
#!/usr/bin/env python3
"""
Interface interativa para adicionar perguntas, treinar e testar o modelo decision-lord.
Uso: python interactive.py
"""

import csv
import os
import sys
import joblib
from collections import OrderedDict

CSV_PATH = "dados.csv"
MODEL_PATH = "modelo_abcd.joblib"


def carregar_perguntas():
    """Lê o CSV e retorna lista de dicts."""
    perguntas = []
    if not os.path.exists(CSV_PATH):
        return perguntas
    with open(CSV_PATH, newline="", encoding="utf-8") as f:
        leitor = csv.DictReader(f)
        for linha in leitor:
            perguntas.append({
                "pergunta": linha["pergunta"],
                "opcoes": {
                    "A": linha["opcao_a"],
                    "B": linha["opcao_b"],
                    "C": linha["opcao_c"],
                    "D": linha["opcao_d"],
                },
                "correta": linha["correta"],
            })
    return perguntas


def salvar_perguntas(perguntas):
    """Salva a lista de perguntas no CSV."""
    with open(CSV_PATH, "w", newline="", encoding="utf-8") as f:
        escritor = csv.DictWriter(
            f,
            fieldnames=["pergunta", "opcao_a", "opcao_b", "opcao_c", "opcao_d", "correta"],
        )
        escritor.writeheader()
        for p in perguntas:
            escritor.writerow({
                "pergunta": p["pergunta"],
                "opcao_a": p["opcoes"]["A"],
                "opcao_b": p["opcoes"]["B"],
                "opcao_c": p["opcoes"]["C"],
                "opcao_d": p["opcoes"]["D"],
                "correta": p["correta"],
            })


def adicionar_pergunta():
    """Coleta nova pergunta do usuário."""
    print("\n" + "=" * 50)
    print("NOVA PERGUNTA")
    print("=" * 50)
    pergunta = input("Pergunta: ").strip()
    if not pergunta:
        return None

    opcoes = {}
    for letra in "ABCD":
        while True:
            opcao = input(f"  Opção {letra}: ").strip()
            if opcao:
                opcoes[letra] = opcao
                break
            print("  Opção não pode estar vazia.")

    while True:
        correta = input("Qual é a correta? (A/B/C/D): ").strip().upper()
        if correta in "ABCD":
            break
        print("  Digite apenas A, B, C ou D.")

    return {"pergunta": pergunta, "opcoes": opcoes, "correta": correta}


def treinar():
    """Re-treina o modelo com todos os dados atuais."""
    import pandas as pd
    from sklearn.feature_extraction.text import TfidfVectorizer
    from sklearn.linear_model import LogisticRegression
    from sklearn.pipeline import Pipeline

    perguntas = carregar_perguntas()
    if len(perguntas) < 5:
        print(f"\n⚠️  Apenas {len(perguntas)} perguntas. Adicione pelo menos 5 pra treinar.")
        return False

    rows = []
    for p in perguntas:
        for letra in "ABCD":
            texto = f"pergunta: {p['pergunta']} | opcao: {p['opcoes'][letra]}"
            rows.append({"texto": texto, "label": 1 if p["correta"] == letra else 0})

    treino = pd.DataFrame(rows)

    modelo = Pipeline([
        ("tfidf", TfidfVectorizer(ngram_range=(1, 2), min_df=1)),
        ("clf", LogisticRegression(max_iter=2000, class_weight="balanced")),
    ])
    modelo.fit(treino["texto"], treino["label"])
    joblib.dump(modelo, MODEL_PATH)

    print(f"\n✅ Modelo treinado com {len(perguntas)} perguntas ({len(treino)} amostras).")
    return True


def testar():
    """Testa o modelo com uma pergunta manual."""
    if not os.path.exists(MODEL_PATH):
        print("\n⚠️  Modelo não treinado ainda. Treine primeiro.")
        return

    modelo = joblib.load(MODEL_PATH)
    perguntas = carregar_perguntas()

    print("\n" + "=" * 50)
    print("TESTE RÁPIDO")
    print("=" * 50)
    pergunta = input("Pergunta: ").strip()
    if not pergunta:
        return

    opcoes = {}
    for letra in "ABCD":
        while True:
            opcao = input(f"  Opção {letra}: ").strip()
            if opcao:
                opcoes[letra] = opcao
                break

    scores = {}
    for letra, texto in opcoes.items():
        entrada = f"pergunta: {pergunta} | opcao: {texto}"
        scores[letra] = modelo.predict_proba([entrada])[0][1]

    melhor = max(scores, key=scores.get)
    print("\n📊 Scores:")
    for k in "ABCD":
        barra = "█" * int(scores[k] * 40)
        print(f"  {k}: {scores[k]:.4f} {barra}")
    print(f"\n✅ Resposta prevista: {melhor}")

    # Mostra se acertou (se a pergunta estiver no dataset)
    for p in perguntas:
        if p["pergunta"].lower() == pergunta.lower():
            if p["correta"] == melhor:
                print("🎉 Acertei a correta!")
            else:
                print(f"❌ Correta seria {p['correta']}.")
            break


def menu():
    while True:
        print("\n" + "=" * 50)
        print("  DECISION-LORD  ·  INTERACTIVE")
        print("=" * 50)
        print("1. Adicionar nova pergunta")
        print("2. Treinar modelo com os dados atuais")
        print("3. Testar modelo")
        print("4. Ver perguntas salvas")
        print("5. Sair")
        print("=" * 50)

        opcao = input("Escolha: ").strip()

        if opcao == "1":
            p = adicionar_pergunta()
            if p:
                perguntas = carregar_perguntas()
                perguntas.append(p)
                salvar_perguntas(perguntas)
                print(f"\n✅ Pergunta salva! ({len(perguntas)} no total)")

        elif opcao == "2":
            treinar()

        elif opcao == "3":
            testar()

        elif opcao == "4":
            perguntas = carregar_perguntas()
            print(f"\n📚 {len(perguntas)} perguntas salvas:")
            for i, p in enumerate(perguntas, 1):
                print(f"  {i}. {p['pergunta'][:60]}... → {p['correta']}")

        elif opcao == "5":
            print("Até logo! 👋")
            sys.exit(0)

        else:
            print("Opção inválida.")


if __name__ == "__main__":
    menu()