Upload folder using huggingface_hub

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rayson Severiano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,80 @@
+---
+library_name: sklearn
+language: pt
+license: mit
+pipeline_tag: text-classification
+tags:
+  - text-classification
+  - intent-classification
+  - lead-scoring
+  - tf-idf
+  - logistic-regression
+  - portuguese
+---
+
+# LeadForge Intent Classifier
+
+Classificador de **intenção de prospecção** (`hot` / `warm` / `cold`) a partir do texto do lead, em português. Pipeline TF-IDF (word n-grams + char_wb n-grams) + Logistic Regression balanceada — sem API paga, sem GPU, determinístico (`random_state=42`).
+
+Faz parte do pipeline do [LeadForge](https://github.com/ranzouu/leadforge). Código completo, CLI e testes: [github.com/ranzouu/leadforge-intent-classifier](https://github.com/ranzouu/leadforge-intent-classifier).
+
+## Métricas — avaliação honesta (out-of-fold)
+
+**StratifiedKFold (5 folds) com tuning de `C` aninhado dentro do fold de treino.** Os números são pooled out-of-fold: toda amostra foi classificada por um modelo que nunca a viu no treino.
+
+| Métrica (média ± desvio entre folds) | Valor |
+|---|---|
+| Accuracy | 0.633 ± 0.192 |
+| Precision (weighted) | 0.634 ± 0.197 |
+| Recall (weighted) | 0.633 ± 0.192 |
+| F1 (weighted) | 0.630 ± 0.189 |
+| F1 (macro) | 0.633 |
+
+| Classe | Precision | Recall | F1 | Suporte |
+|---|---|---|---|---|
+| cold | 0.700 | 0.700 | 0.700 | 20 |
+| hot | 0.750 | 0.750 | 0.750 | 20 |
+| warm | 0.450 | 0.450 | 0.450 | 20 |
+
+> Nota de integridade: uma versão anterior deste projeto publicava "accuracy 1.0" medida no mesmo conjunto usado no treino (avaliação in-sample — inflação). Esse número foi removido e substituído pela validação cruzada acima. Detalhes por fold em `runs/cv_folds.csv` e por classe em `runs/class_report.csv`.
+
+## Uso
+
+```python
+import joblib
+
+vectorizer = joblib.load("vectorizer.pkl")
+clf = joblib.load("model.pkl")
+
+frases = [
+    "Quero fechar um plano hoje para minha barbearia",   # hot
+    "Pode me explicar melhor como funciona?",            # warm
+    "Só estou olhando por curiosidade",                  # cold
+]
+print(clf.predict(vectorizer.transform([f.lower() for f in frases])))
+```
+
+## Limitações (lé com atenção)
+
+- **Dataset de demonstração**: 60 amostras (20 por classe) escritas para exercitar o pipeline — não são leads reais de produção. Em produção, treinar com dados reais e revalidar antes de confiar.
+- **`warm` é a fronteira difícil** (F1 0.45): separar "interesse" de "só curiosidade" é tênue até em leitura humana.
+- Modelo linha de base (TF-IDF + LR); com dados reais e volume maior, comparar com alternativas (LinearSVC, gradient boosting, LLM zero-shot) antes de escolher.
+
+## Reproduzir
+
+```bash
+pip install -e .                 # do repositório
+python -m leadforge_intent_classifier
+# runs/summary.csv, runs/cv_folds.csv, runs/class_report.csv, runs/latest.csv
+```
+
+## Arquivos
+
+| Arquivo | Conteúdo |
+|---|---|
+| `model.pkl` | Logistic Regression final (treinada nos 60 samples, `C=4.0`) |
+| `vectorizer.pkl` | FeatureUnion word(1,2) + char_wb(2,4), `sublinear_tf` |
+| `experiment.py` | código-fonte do pipeline (treino, nested CV, exportação) |
+| `data/sample_leads.json` | dataset de demo (60 amostras) |
+| `runs/*.csv` | métricas por fold, por classe e predições out-of-fold |
+| `LICENSE` | MIT |

data/sample_leads.json

@@ -0,0 +1,62 @@
+[
+  {"id": 1, "text": "Quero contratar um plano de musculação para minha academia", "label": "hot"},
+  {"id": 2, "text": "Preciso de um site para meu petshop", "label": "hot"},
+  {"id": 3, "text": "Quero automatizar o cardápio do meu restaurante", "label": "hot"},
+  {"id": 4, "text": "Estou procurando um sistema para minha loja", "label": "warm"},
+  {"id": 5, "text": "Quero melhorar a organização da minha academia", "label": "warm"},
+  {"id": 6, "text": "Meu petshop precisa de um sistema de agenda", "label": "warm"},
+  {"id": 7, "text": "Quero entender mais sobre automação", "label": "cold"},
+  {"id": 8, "text": "Estou apenas pesquisando opções", "label": "cold"},
+  {"id": 9, "text": "Quero um aplicativo para meu negócio", "label": "hot"},
+  {"id": 10, "text": "Preciso de ajuda com marketing digital", "label": "warm"},
+  {"id": 11, "text": "Só queria ver como funciona", "label": "cold"},
+  {"id": 12, "text": "Quero contratar um personal para minha academia", "label": "hot"},
+  {"id": 13, "text": "Estou começando um petshop e preciso de ajuda", "label": "warm"},
+  {"id": 14, "text": "Quero criar um site institucional", "label": "hot"},
+  {"id": 15, "text": "Ainda não sei se preciso de um sistema", "label": "cold"},
+  {"id": 16, "text": "Quero fechar um plano hoje para minha barbearia", "label": "hot"},
+  {"id": 17, "text": "Preciso contratar um sistema pro meu salão essa semana", "label": "hot"},
+  {"id": 18, "text": "Quero um site pra minha loja de roupas, pode mandar proposta", "label": "hot"},
+  {"id": 19, "text": "Quero automatizar os agendamentos da minha clínica veterinária", "label": "hot"},
+  {"id": 20, "text": "Meu delivery precisa de cardápio digital, quero contratar", "label": "hot"},
+  {"id": 21, "text": "Quero começar esse mês, como faço pra assinar?", "label": "hot"},
+  {"id": 22, "text": "Quero contratar o serviço de marketing pra minha padaria", "label": "hot"},
+  {"id": 23, "text": "Tenho interesse em contratar, me manda os valores dos planos", "label": "hot"},
+  {"id": 24, "text": "Quero um e-commerce pra minha loja de calçados", "label": "hot"},
+  {"id": 25, "text": "Preciso de um app pra minha academia, quero fechar", "label": "hot"},
+  {"id": 26, "text": "Quero modernizar minha loja e fechar com vocês", "label": "hot"},
+  {"id": 27, "text": "Me manda o contrato que eu quero assinar essa semana", "label": "hot"},
+  {"id": 28, "text": "Quero colocar meu restaurante no aplicativo de entregas", "label": "hot"},
+  {"id": 29, "text": "Quero ter presença digital, quero contratar agora", "label": "hot"},
+  {"id": 30, "text": "Estou pesquisando sistemas pra minha oficina mecânica", "label": "warm"},
+  {"id": 31, "text": "Meu salão precisa de agenda, estou comparando opções", "label": "warm"},
+  {"id": 32, "text": "Pode me explicar melhor como funciona a automação?", "label": "warm"},
+  {"id": 33, "text": "Estou pensando em modernizar minha loja no próximo ano", "label": "warm"},
+  {"id": 34, "text": "Quanto tempo leva pra implementar no meu negócio?", "label": "warm"},
+  {"id": 35, "text": "Queria saber os valores antes de decidir", "label": "warm"},
+  {"id": 36, "text": "Meu restaurante tá crescendo e preciso me organizar melhor", "label": "warm"},
+  {"id": 37, "text": "Ouvi falar do serviço, quero conhecer melhor", "label": "warm"},
+  {"id": 38, "text": "Estou juntando propostas pra minha clínica", "label": "warm"},
+  {"id": 39, "text": "Ainda estou vendo se vale a pena investir", "label": "warm"},
+  {"id": 40, "text": "Meu sócio falou pra eu procurar vocês", "label": "warm"},
+  {"id": 41, "text": "Quero melhorar o atendimento do meu petshop", "label": "warm"},
+  {"id": 42, "text": "Como funciona pra quem tem duas lojas?", "label": "warm"},
+  {"id": 43, "text": "Tenho uma papelaria e queria saber mais", "label": "warm"},
+  {"id": 44, "text": "Dá pra integrar com o sistema que já uso?", "label": "warm"},
+  {"id": 45, "text": "Só estou olhando por curiosidade, sem compromisso", "label": "cold"},
+  {"id": 46, "text": "Achei interessante mas é só curiosidade", "label": "cold"},
+  {"id": 47, "text": "Talvez no futuro, obrigado", "label": "cold"},
+  {"id": 48, "text": "Quero só entender a plataforma por enquanto", "label": "cold"},
+  {"id": 49, "text": "Estou vendo preços no mercado, sem pressa", "label": "cold"},
+  {"id": 50, "text": "Recebi a mensagem no grupo, só vim ver", "label": "cold"},
+  {"id": 51, "text": "Não estou precisando no momento", "label": "cold"},
+  {"id": 52, "text": "Queria só saber o que o app faz", "label": "cold"},
+  {"id": 53, "text": "Meu negócio é pequeno demais pra isso agora", "label": "cold"},
+  {"id": 54, "text": "Só queria guardar o contato pra depois", "label": "cold"},
+  {"id": 55, "text": "Tô explorando, não sei nem se preciso", "label": "cold"},
+  {"id": 56, "text": "Curiosidade mesmo, pode me mandar o material", "label": "cold"},
+  {"id": 57, "text": "Vi o anúncio, mas não tenho interesse agora", "label": "cold"},
+  {"id": 58, "text": "Só queria saber o preço, mas não pretendo contratar", "label": "cold"},
+  {"id": 59, "text": "Vim só dar uma olhada", "label": "cold"},
+  {"id": 60, "text": "Sem interesse por enquanto, valeu", "label": "cold"}
+]

experiment.py

@@ -0,0 +1,340 @@
+from __future__ import annotations
+
+import csv
+import json
+import statistics
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Iterable
+
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+from sklearn.model_selection import StratifiedKFold, train_test_split
+from sklearn.pipeline import FeatureUnion
+
+DATA_PATH = Path(__file__).resolve().parents[2] / "data" / "sample_leads.json"
+MODEL_DIR = Path(__file__).resolve().parents[2] / "model"
+RUNS_DIR = Path(__file__).resolve().parents[2] / "runs"
+
+CV_FOLDS = 5
+RANDOM_STATE = 42
+C_GRID = [0.5, 1.0, 2.0, 4.0]
+
+
+def _make_features() -> FeatureUnion:
+    """Uniao de features: word n-grams (sintaxe) + char_wb n-grams (morfologia
+    do PT-BR — pega radical de 'contrat/automat/pesquis' sem depender de stemmer).
+    """
+    return FeatureUnion(
+        [
+            ("word", TfidfVectorizer(ngram_range=(1, 2), min_df=1, sublinear_tf=True)),
+            ("char", TfidfVectorizer(analyzer="char_wb", ngram_range=(2, 4), min_df=1, sublinear_tf=True)),
+        ]
+    )
+
+
+def _make_clf(C: float = 1.0) -> LogisticRegression:
+    return LogisticRegression(max_iter=2000, class_weight="balanced", random_state=RANDOM_STATE, C=C)
+
+
+def _tune_c(texts: list[str], labels: list[str]) -> tuple[float, dict]:
+    """Grid manual de C com CV interno — usado DENTRO do fold de treino
+    (nested CV): o tuning nunca ve o fold de teste.
+    """
+    best_c, best_score = 1.0, -1.0
+    scores: dict[str, float] = {}
+    inner = StratifiedKFold(n_splits=3, shuffle=True, random_state=RANDOM_STATE)
+    for c in C_GRID:
+        fold_scores = []
+        for tr, va in inner.split(texts, labels):
+            vec = _make_features()
+            X_tr = vec.fit_transform([texts[i] for i in tr])
+            X_va = vec.transform([texts[i] for i in va])
+            clf = _make_clf(c)
+            clf.fit(X_tr, [labels[i] for i in tr])
+            _, _, f1, _ = precision_recall_fscore_support(
+                [labels[i] for i in va], clf.predict(X_va), average="macro", zero_division=0
+            )
+            fold_scores.append(float(f1))
+        mean = float(np.mean(fold_scores))
+        scores[str(c)] = round(mean, 4)
+        if mean > best_score:
+            best_c, best_score = c, mean
+    return best_c, scores
+
+
+@dataclass
+class Lead:
+    id: int
+    text: str
+    label: str
+
+
+@dataclass
+class RunRecord:
+    id: int
+    text: str
+    expected: str
+    predicted: str
+    correct: bool = False
+
+
+def _load_leads() -> list[Lead]:
+    with open(DATA_PATH, "r", encoding="utf-8") as f:
+        return [Lead(**item) for item in json.load(f)]
+
+
+def _preprocess(text: str) -> str:
+    return text.lower()
+
+
+def _make_pipeline():
+    return (
+        TfidfVectorizer(ngram_range=(1, 2), min_df=1),
+        LogisticRegression(max_iter=1000, class_weight="balanced", random_state=RANDOM_STATE),
+    )
+
+
+def train_model(leads: list[Lead]):
+    """Treina o artefato final em TODOS os dados (uso em producao/demo).
+
+    O C vem de grid CV em dados completos; a avaliacao honesta NAO usa este
+    modelo — ver `cross_validate` (tuning aninhado dentro de cada fold).
+    """
+    texts = [_preprocess(l.text) for l in leads]
+    labels = [l.label for l in leads]
+
+    best_c, _ = _tune_c(texts, labels)
+    vectorizer = _make_features()
+    X = vectorizer.fit_transform(texts)
+    clf = _make_clf(best_c)
+    clf.fit(X, labels)
+    clf.C_TUNED = best_c  # type: ignore[attr-defined]
+
+    return vectorizer, clf
+
+
+def evaluate(vectorizer, clf, leads: list[Lead]) -> tuple[list[RunRecord], dict]:
+    """Avaliacao in-sample (smoke test). NAO usar como metrica publicada:
+    aqui o modelo ve os mesmos exemplos no treino e na avaliacao.
+    """
+    texts = [_preprocess(l.text) for l in leads]
+    X = vectorizer.transform(texts)
+    preds = clf.predict(X)
+
+    records: list[RunRecord] = []
+    for lead, pred in zip(leads, preds):
+        records.append(
+            RunRecord(id=lead.id, text=lead.text, expected=lead.label, predicted=str(pred), correct=str(pred) == lead.label)
+        )
+
+    acc = accuracy_score([r.expected for r in records], [r.predicted for r in records])
+    precision, recall, f1, _ = precision_recall_fscore_support(
+        [r.expected for r in records], [r.predicted for r in records], average="weighted", zero_division=0
+    )
+
+    summary = {
+        "accuracy": round(float(acc), 4),
+        "precision": round(float(precision), 4),
+        "recall": round(float(recall), 4),
+        "f1": round(float(f1), 4),
+        "samples": len(records),
+        "mode": "in-sample",
+    }
+    return records, summary
+
+
+def cross_validate(leads: list[Lead], k: int = CV_FOLDS) -> tuple[list[RunRecord], dict, list[dict], list[dict]]:
+    """Avaliacao honesta: StratifiedKFold com vectorizer treinado SOMENTE
+    no fold de treino (sem vazamento). Retorna predicoes pooled out-of-fold,
+    resumo com media + desvio por fold, linhas por fold e relatorio por classe.
+    """
+    texts = [_preprocess(l.text) for l in leads]
+    labels = [l.label for l in leads]
+    classes = sorted(set(labels))
+
+    skf = StratifiedKFold(n_splits=k, shuffle=True, random_state=RANDOM_STATE)
+    pooled: list[RunRecord] = []
+    fold_rows: list[dict] = []
+    fold_weighted: list[dict] = []
+    tuned_cs: list[float] = []
+
+    for fold, (train_idx, test_idx) in enumerate(skf.split(texts, labels), start=1):
+        train_texts = [texts[i] for i in train_idx]
+        train_labels = [labels[i] for i in train_idx]
+
+        # tuning aninhado: C escolhido só com o fold de treino
+        best_c, _ = _tune_c(train_texts, train_labels)
+        tuned_cs.append(best_c)
+
+        vectorizer = _make_features()
+        X_train = vectorizer.fit_transform(train_texts)
+        clf = _make_clf(best_c)
+        clf.fit(X_train, train_labels)
+        preds = clf.predict(vectorizer.transform([texts[i] for i in test_idx]))
+
+        for idx, pred in zip(test_idx, preds):
+            pooled.append(
+                RunRecord(id=leads[idx].id, text=leads[idx].text, expected=labels[idx], predicted=str(pred))
+            )
+
+        y_true = [labels[i] for i in test_idx]
+        precision, recall, f1, _ = precision_recall_fscore_support(
+            y_true, preds, average="weighted", zero_division=0
+        )
+        fold_weighted.append(
+            {
+                "accuracy": float(accuracy_score(y_true, preds)),
+                "precision": float(precision),
+                "recall": float(recall),
+                "f1": float(f1),
+            }
+        )
+        fold_rows.append(
+            {
+                "fold": fold,
+                "train": len(train_idx),
+                "test": len(test_idx),
+                "accuracy": round(fold_weighted[-1]["accuracy"], 4),
+                "precision": round(fold_weighted[-1]["precision"], 4),
+                "recall": round(fold_weighted[-1]["recall"], 4),
+                "f1": round(fold_weighted[-1]["f1"], 4),
+            }
+        )
+
+    y_true = [r.expected for r in pooled]
+    y_pred = [r.predicted for r in pooled]
+
+    pooled_precision, pooled_recall, pooled_f1, support = precision_recall_fscore_support(
+        y_true, y_pred, labels=classes, zero_division=0
+    )
+    macro_precision, macro_recall, macro_f1, _ = precision_recall_fscore_support(
+        y_true, y_pred, average="macro", zero_division=0
+    )
+
+    class_rows = [
+        {
+            "class": cls,
+            "precision": round(float(p), 4),
+            "recall": round(float(r), 4),
+            "f1": round(float(f), 4),
+            "support": int(s),
+        }
+        for cls, p, r, f, s in zip(classes, pooled_precision, pooled_recall, pooled_f1, support)
+    ]
+
+    def _mean_std(key: str) -> tuple[float, float]:
+        values = [row[key] for row in fold_weighted]
+        return float(statistics.mean(values)), float(statistics.stdev(values) if len(values) > 1 else 0.0)
+
+    mean_acc, std_acc = _mean_std("accuracy")
+    mean_p, std_p = _mean_std("precision")
+    mean_r, std_r = _mean_std("recall")
+    mean_f1, std_f1 = _mean_std("f1")
+
+    summary = {
+        "mode": f"cv{k}",
+        "accuracy": round(mean_acc, 4),
+        "accuracy_std": round(std_acc, 4),
+        "precision": round(mean_p, 4),
+        "precision_std": round(std_p, 4),
+        "recall": round(mean_r, 4),
+        "recall_std": round(std_r, 4),
+        "f1": round(mean_f1, 4),
+        "f1_std": round(std_f1, 4),
+        "macro_f1": round(float(macro_f1), 4),
+        "folds": k,
+        "samples": len(pooled),
+        "c_per_fold": ";".join(str(c) for c in tuned_cs),
+        "_fold_rows": fold_rows,
+        "_class_rows": class_rows,
+    }
+    return pooled, summary, fold_rows, class_rows
+
+
+def save_runs(records: list[RunRecord], summary: dict, runs_dir: str = "runs") -> tuple[Path, Path]:
+    runs = Path(runs_dir)
+    runs.mkdir(parents=True, exist_ok=True)
+
+    latest_path = runs / "latest.csv"
+    summary_path = runs / "summary.csv"
+
+    with open(latest_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=list(RunRecord.__dataclass_fields__.keys()))
+        writer.writeheader()
+        for r in records:
+            writer.writerow(asdict(r))
+
+    detail = {k: summary.pop(k) for k in list(summary) if k.startswith("_")}
+    with open(summary_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=list(summary.keys()))
+        writer.writeheader()
+        writer.writerow(summary)
+
+    for key, name in (("_fold_rows", "cv_folds.csv"), ("_class_rows", "class_report.csv")):
+        if key in detail:
+            with open(runs / name, "w", newline="", encoding="utf-8") as f:
+                writer = csv.DictWriter(f, fieldnames=list(detail[key][0].keys()))
+                writer.writeheader()
+                writer.writerows(detail[key])
+
+    return latest_path, summary_path
+
+
+def predict_text(vectorizer, clf, text: str) -> str:
+    X = vectorizer.transform([_preprocess(text)])
+    return str(clf.predict(X)[0])
+
+
+def _demo_predict(text: str) -> str:
+    t = text.lower()
+    if any(w in t for w in ["quero contratar", "quero automatizar", "preciso de um site", "quero um aplicativo", "quero contratar um personal"]):
+        return "hot"
+    if any(w in t for w in ["estou procurando", "quero melhorar", "precisa de um sistema", "precisa de ajuda", "começando"]):
+        return "warm"
+    return "cold"
+
+
+def run_experiment(demo: bool = False, k: int = CV_FOLDS) -> tuple[list[RunRecord], dict]:
+    """Fluxo principal.
+
+    demo=True: classificacao por regras (sem treino).
+    demo=False: treina o artefato final em todos os dados E publica as metricas
+    honestas de validacao cruzada estratificada (out-of-fold) em runs/.
+    """
+    leads = _load_leads()
+    MODEL_DIR.mkdir(parents=True, exist_ok=True)
+    RUNS_DIR.mkdir(parents=True, exist_ok=True)
+
+    if demo:
+        records = []
+        for l in leads:
+            pred = _demo_predict(l.text)
+            records.append(
+                RunRecord(id=l.id, text=l.text, expected=l.label, predicted=pred, correct=pred == l.label)
+            )
+        acc = sum(1 for r in records if r.correct) / max(len(records), 1)
+        precision, recall, f1, _ = precision_recall_fscore_support(
+            [r.expected for r in records], [r.predicted for r in records], average="weighted", zero_division=0
+        )
+        summary = {
+            "accuracy": round(float(acc), 4),
+            "precision": round(float(precision), 4),
+            "recall": round(float(recall), 4),
+            "f1": round(float(f1), 4),
+            "samples": len(records),
+            "mode": "demo",
+        }
+        return records, summary
+
+    import joblib
+
+    vectorizer, clf = train_model(leads)
+    joblib.dump(vectorizer, MODEL_DIR / "vectorizer.pkl")
+    joblib.dump(clf, MODEL_DIR / "model.pkl")
+
+    records, summary, _, _ = cross_validate(leads, k=k)
+    summary["final_C"] = float(getattr(clf, "C_TUNED", clf.C))
+    return records, summary

model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b59eb40aaab924e5fa4d37cc6ccd31b457b6f9ec976193ab48974dcaf0bc319
+size 51586

runs/class_report.csv

@@ -0,0 +1,4 @@
+class,precision,recall,f1,support
+cold,0.7,0.7,0.7,20
+hot,0.75,0.75,0.75,20
+warm,0.45,0.45,0.45,20

runs/cv_folds.csv

@@ -0,0 +1,6 @@
+fold,train,test,accuracy,precision,recall,f1
+1,48,12,0.5,0.5,0.5,0.5
+2,48,12,0.5,0.5,0.5,0.5
+3,48,12,0.75,0.7389,0.75,0.7368
+4,48,12,0.9167,0.9333,0.9167,0.9153
+5,48,12,0.5,0.5,0.5,0.5

runs/summary.csv

@@ -0,0 +1,2 @@
+mode,accuracy,accuracy_std,precision,precision_std,recall,recall_std,f1,f1_std,macro_f1,folds,samples,c_per_fold,final_C
+cv5,0.6333,0.1918,0.6344,0.1965,0.6333,0.1918,0.6304,0.1894,0.6333,5,60,2.0;0.5;0.5;2.0;0.5,4.0

vectorizer.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b089dbf24a56312e477d0f44ce3e0cf579995b3f2cb308e243329b75429c6c84
+size 40357