Buat data saya agar bisa terbaca algoritmanya untu...

python
import pandas as pd, os, json, textwrap, numpy as np, re, csv, pathlib, sys
path='/mnt/data/data_history.txt'
print(os.path.exists(path), os.path.getsize(path))
# Read first lines
with open(path,'r',encoding='utf-8-sig') as f:
    for i in range(5):
        print(repr(f.readline()[:200]))
# try pandas
df = pd.read_csv(path, dtype=str)
print(df.shape)
print(df.head())
print(df.tail())
print(df.columns.tolist())
print(df.isna().sum().to_dict())

python
import pandas as pd
import json, textwrap, os, re
from pathlib import Path

src = Path("/mnt/data/data_history.txt")
out_clean = Path("/mnt/data/data_history_cleaned.csv")
out_py = Path("/mnt/data/script_prediksi_colab.py")
out_ipynb = Path("/mnt/data/prediksi_hasil_colab.ipynb")

# Build cleaned dataset from the uploaded file
df = pd.read_csv(src, dtype=str)

MONTH_ID = {
    "januari": 1, "februari": 2, "maret": 3, "april": 4,
    "mei": 5, "juni": 6, "juli": 7, "agustus": 8,
    "september": 9, "oktober": 10, "november": 11, "desember": 12
}

def parse_tanggal_id(s):
    parts = str(s).strip().lower().split()
    if len(parts) != 3:
        raise ValueError(f"Format tanggal tidak dikenali: {s}")
    day = int(parts[0])
    month = MONTH_ID[parts[1]]
    year = int(parts[2])
    return pd.Timestamp(year=year, month=month, day=day)

df["tanggal_dt"] = df["Tanggal"].apply(parse_tanggal_id)
df["datetime"] = pd.to_datetime(df["tanggal_dt"].dt.strftime("%Y-%m-%d") + " " + df["Waktu"])
df = df.sort_values("datetime").reset_index(drop=True)

num_cols = [c for c in df.columns if c not in ["Tanggal", "Waktu", "tanggal_dt", "datetime"]]
for c in num_cols:
    df[c] = df[c].astype(str).str.replace(r"\D", "", regex=True).str.zfill(4).str[-4:]
    df[f"{c}_int"] = df[c].astype(int)
    for i in range(4):
        df[f"{c}_d{i+1}"] = df[c].str[i].astype(int)

df["tahun"] = df["datetime"].dt.year
df["bulan"] = df["datetime"].dt.month
df["hari"] = df["datetime"].dt.day
df["hari_ke_minggu"] = df["datetime"].dt.dayofweek
df["jam"] = df["datetime"].dt.hour
df["menit"] = df["datetime"].dt.minute
df["urutan"] = range(len(df))

df.to_csv(out_clean, index=False)

script = r'''
# ============================================================
# SCRIPT GOOGLE COLAB: Baca data history, rapikan, dan prediksi hasil berikutnya
# ============================================================
# Catatan penting:
# - Untuk data undian/acak, model TIDAK bisa menjamin hasil benar.
# - Script ini membuat data menjadi terbaca algoritma ML, lalu mencari pola statistik jika ada.
# - Target default: "1st Prize". Ganti TARGET_COL jika ingin memprediksi kolom lain.
# ============================================================

# 1) Upload file data_history.txt ke Colab
from google.colab import files
uploaded = files.upload()

import pandas as pd
import numpy as np
import re
from pathlib import Path

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report
from sklearn.model_selection import TimeSeriesSplit

# 2) Ambil nama file yang di-upload
FILE_NAME = list(uploaded.keys())[0]
TARGET_COL = "1st Prize"      # ganti ke: "2nd Prize", "3rd Prize", "Lucky1", dst.
N_LAG = 8                     # jumlah hasil sebelumnya sebagai fitur
RANDOM_STATE = 42

# 3) Baca CSV/TXT, semua kolom dibuat string agar nol depan tidak hilang
df = pd.read_csv(FILE_NAME, dtype=str)

# 4) Parsing tanggal Indonesia
MONTH_ID = {
    "januari": 1, "februari": 2, "maret": 3, "april": 4,
    "mei": 5, "juni": 6, "juli": 7, "agustus": 8,
    "september": 9, "oktober": 10, "november": 11, "desember": 12
}

def parse_tanggal_id(s):
    parts = str(s).strip().lower().split()
    if len(parts) != 3:
        raise ValueError(f"Format tanggal tidak dikenali: {s}")
    return pd.Timestamp(year=int(parts[2]), month=MONTH_ID[parts[1]], day=int(parts[0]))

df["tanggal_dt"] = df["Tanggal"].apply(parse_tanggal_id)
df["datetime"] = pd.to_datetime(df["tanggal_dt"].dt.strftime("%Y-%m-%d") + " " + df["Waktu"])
df = df.sort_values("datetime").reset_index(drop=True)

# 5) Bersihkan kolom angka 4 digit dan pecah menjadi digit
num_cols = [c for c in df.columns if c not in ["Tanggal", "Waktu", "tanggal_dt", "datetime"]]

for c in num_cols:
    df[c] = df[c].astype(str).str.replace(r"\D", "", regex=True).str.zfill(4).str[-4:]
    df[f"{c}_int"] = df[c].astype(int)
    for i in range(4):
        df[f"{c}_d{i+1}"] = df[c].str[i].astype(int)

# 6) Fitur waktu
df["tahun"] = df["datetime"].dt.year
df["bulan"] = df["datetime"].dt.month
df["hari"] = df["datetime"].dt.day
df["hari_ke_minggu"] = df["datetime"].dt.dayofweek
df["jam"] = df["datetime"].dt.hour
df["menit"] = df["datetime"].dt.minute
df["urutan"] = np.arange(len(df))

# Simpan data yang sudah rapi
df.to_csv("data_history_cleaned.csv", index=False)
print("Data bersih disimpan sebagai: data_history_cleaned.csv")
print("Jumlah baris:", len(df))
print(df[["datetime", TARGET_COL]].tail())

# 7) Buat fitur lag: hasil-hasil sebelumnya dipakai untuk memprediksi hasil berikutnya
def make_lag_features(data, target_col, n_lag=8):
    work = data.copy()
    
    # Fitur waktu saat draw
    feature_cols = ["tahun", "bulan", "hari", "hari_ke_minggu", "jam", "menit", "urutan"]
    
    # Pakai digit target sebelumnya sebagai lag
    for lag in range(1, n_lag + 1):
        work[f"{target_col}_lag{lag}_int"] = work[f"{target_col}_int"].shift(lag)
        feature_cols.append(f"{target_col}_lag{lag}_int")
        for d in range(1, 5):
            col = f"{target_col}_d{d}"
            work[f"{col}_lag{lag}"] = work[col].shift(lag)
            feature_cols.append(f"{col}_lag{lag}")
    
    # Target dibuat per digit agar model tidak harus memilih langsung dari 0000-9999
    target_digit_cols = [f"{target_col}_d1", f"{target_col}_d2", f"{target_col}_d3", f"{target_col}_d4"]
    
    model_df = work.dropna(subset=feature_cols + target_digit_cols).copy()
    X = model_df[feature_cols].astype(float)
    y = model_df[target_digit_cols].astype(int)
    return model_df, X, y, feature_cols, target_digit_cols

model_df, X, y, feature_cols, target_digit_cols = make_lag_features(df, TARGET_COL, N_LAG)

# 8) Split time-series: data awal untuk train, data akhir untuk test
split_idx = int(len(model_df) * 0.8)
X_train, X_test = X.iloc[:split_idx], X.iloc[split_idx:]
y_train, y_test = y.iloc[:split_idx], y.iloc[split_idx:]

models = {}
pred_digits = []

print("\nEvaluasi per digit pada data test:")
for digit_col in target_digit_cols:
    clf = RandomForestClassifier(
        n_estimators=500,
        max_depth=None,
        min_samples_leaf=2,
        random_state=RANDOM_STATE,
        class_weight="balanced_subsample",
        n_jobs=-1
    )
    clf.fit(X_train, y_train[digit_col])
    pred = clf.predict(X_test)
    acc = accuracy_score(y_test[digit_col], pred)
    print(f"{digit_col}: accuracy = {acc:.3f}")
    models[digit_col] = clf
    pred_digits.append(pred)

# Akurasi full 4 digit pada test
pred_4d = ["".join(str(pred_digits[d][i]) for d in range(4)) for i in range(len(X_test))]
true_4d = model_df.iloc[split_idx:][TARGET_COL].tolist()
full_acc = np.mean([p == t for p, t in zip(pred_4d, true_4d)])
print(f"\nAkurasi tepat 4 digit pada test: {full_acc:.3f}")
print("Catatan: Untuk data acak, akurasi 4 digit biasanya sangat rendah.")

# 9) Prediksi draw berikutnya
# Buat baris fitur next draw berdasarkan jadwal waktu yang biasanya berulang.
# Script ini mencari waktu draw berikutnya dari pola waktu yang ada.
def next_draw_datetime(data):
    times = sorted(data["datetime"].dt.strftime("%H:%M").unique())
    last_dt = data["datetime"].max()
    last_date = last_dt.normalize()
    
    candidates = []
    for t in times:
        hh, mm = map(int, t.split(":"))
        cand = last_date + pd.Timedelta(hours=hh, minutes=mm)
        if cand > last_dt:
            candidates.append(cand)
    if candidates:
        return min(candidates)
    
    # jika semua jam hari ini sudah lewat, ambil jam pertama besok
    hh, mm = map(int, times[0].split(":"))
    return last_date + pd.Timedelta(days=1, hours=hh, minutes=mm)

next_dt = next_draw_datetime(df)

def build_next_row(data, target_col, n_lag, next_dt, feature_cols):
    row = {
        "tahun": next_dt.year,
        "bulan": next_dt.month,
        "hari": next_dt.day,
        "hari_ke_minggu": next_dt.dayofweek,
        "jam": next_dt.hour,
        "menit": next_dt.minute,
        "urutan": len(data)
    }
    
    for lag in range(1, n_lag + 1):
        src = data.iloc[-lag]
        row[f"{target_col}_lag{lag}_int"] = int(src[f"{target_col}_int"])
        for d in range(1, 5):
            row[f"{target_col}_d{d}_lag{lag}"] = int(src[f"{target_col}_d{d}"])
            
    return pd.DataFrame([row])[feature_cols].astype(float)

X_next = build_next_row(df, TARGET_COL, N_LAG, next_dt, feature_cols)

next_digits = []
digit_prob_info = []

for digit_col in target_digit_cols:
    model = models[digit_col]
    proba = model.predict_proba(X_next)[0]
    classes = model.classes_
    best_idx = int(np.argmax(proba))
    best_digit = int(classes[best_idx])
    best_prob = float(proba[best_idx])
    next_digits.append(str(best_digit))
    digit_prob_info.append((digit_col, best_digit, best_prob))

prediksi_berikutnya = "".join(next_digits)

print("\n================ HASIL PREDIKSI ================")
print("Target kolom        :", TARGET_COL)
print("Datetime berikutnya :", next_dt)
print("Prediksi 4 digit    :", prediksi_berikutnya)
print("\nProbabilitas digit terpilih:")
for digit_col, digit, prob in digit_prob_info:
    print(f"- {digit_col}: {digit} dengan estimasi probabilitas {prob:.3f}")

# 10) Tampilkan 10 prediksi terakhir vs aktual sebagai sanity check
hasil_test = pd.DataFrame({
    "datetime": model_df.iloc[split_idx:]["datetime"].values,
    "aktual": true_4d,
    "prediksi": pred_4d
})
print("\nContoh prediksi vs aktual pada data test:")
print(hasil_test.tail(10))

# Download file data bersih bila perlu
files.download("data_history_cleaned.csv")
'''

out_py.write_text(script.strip() + "\n", encoding="utf-8")

notebook = {
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Prediksi Hasil Berikutnya\n",
                "\n",
                "Notebook ini membaca `data_history.txt`, membersihkan data 4 digit agar nol depan tetap aman, membuat fitur waktu dan lag, lalu melatih model RandomForest per digit.\n",
                "\n",
                "**Catatan:** Jika data bersifat undian/acak, prediksi tidak bisa dijamin benar. Script ini hanya mencari pola statistik dari riwayat data."
            ],
        },
        {
            "cell_type": "code",
            "execution_count": None,
            "metadata": {},
            "outputs": [],
            "source": script.strip().splitlines(True),
        },
    ],
    "metadata": {
        "colab": {"provenance": []},
        "kernelspec": {"display_name": "Python 3", "name": "python3"},
        "language_info": {"name": "python", "version": "3.x"},
    },
    "nbformat": 4,
    "nbformat_minor": 5,
}
out_ipynb.write_text(json.dumps(notebook, ensure_ascii=False, indent=2), encoding="utf-8")

print("File dibuat:")
print(out_clean)
print(out_py)
print(out_ipynb)
print("Preview data bersih:")
print(pd.read_csv(out_clean, dtype=str).head(3)[["datetime", "1st Prize", "2nd Prize", "3rd Prize"]].to_string(index=False))