Prediksi untuk hasil selanjutnya yang akurat

python
import json, os, textwrap, pandas as pd, numpy as np, re, math, statistics
path='/mnt/data/data_ekstraksi.json'
os.path.exists(path), os.path.getsize(path)

python
import json, os, textwrap, pandas as pd, numpy as np, re, math, statistics
path='/mnt/data/data_ekstraksi.json'
print(os.path.exists(path), os.path.getsize(path))
with open(path,'r',encoding='utf-8') as f:
    data=json.load(f)
type(data), len(data), data[0].keys(), data[0]['tanggal'], data[0]['waktu'], len(data[0]['daftar_prize'])


(list,
 645,
 dict_keys(['tanggal', 'waktu', 'daftar_prize']),
 '10 Februari 2026',
 '21:30',
 13)

python
data[-3:]


[{'tanggal': '29 Mei 2026',
  'waktu': '21:30',
  'daftar_prize': [{'kode': '8454', 'angka': [0, 1, 2, 3, 6, 7, 9]},
   {'kode': '5906', 'angka': [1, 2, 3, 4, 7, 8]},
   {'kode': '3294', 'angka': [0, 1, 5, 6, 7, 8]},
   {'kode': '0491', 'angka': [2, 3, 5, 6, 7, 8]},
   {'kode': '0302', 'angka': [1, 4, 5, 6, 7, 8, 9]},
   {'kode': '9610', 'angka': [2, 3, 4, 5, 7, 8]},
   {'kode': '1017', 'angka': [2, 3, 4, 5, 6, 8, 9]},
   {'kode': '3490', 'angka': [1, 2, 5, 6, 7, 8]},
   {'kode': '1588', 'angka': [0, 2, 3, 4, 6, 7, 9]},
   {'kode': '5763', 'angka': [0, 1, 2, 4, 8, 9]},
   {'kode': '8529', 'angka': [0, 1, 3, 4, 6, 7]},
   {'kode': '4732', 'angka': [0, 1, 5, 6, 8, 9]},
   {'kode': '8571', 'angka': [0, 2, 3, 4, 6, 9]}]},
 {'tanggal': '30 Mei 2026',
  'waktu': '03:30',
  'daftar_prize': [{'kode': '5282', 'angka': [0, 1, 3, 4, 6, 7, 9]},
   {'kode': '8368', 'angka': [0, 1, 2, 4, 5, 7, 9]},
   {'kode': '0338', 'angka': [1, 2, 4, 5, 6, 7, 9]},
   {'kode': '9217', 'angka': [0, 3, 4, 5, 6, 8]},
   {'kode': '1632', 'angka': [0, 4, 5, 7, 8, 9]},
   {'kode': '6303', 'angka': [1, 2, 4, 5, 7, 8, 9]},
   {'kode': '5016', 'angka': [2, 3, 4, 7, 8, 9]},
   {'kode': '7698', 'angka': [0, 1, 2, 3, 4, 5]},
   {'kode': '0893', 'angka': [1, 2, 4, 5, 6, 7]},
   {'kode': '2251', 'angka': [0, 3, 4, 6, 7, 8, 9]},
   {'kode': '4553', 'angka': [0, 1, 2, 6, 7, 8, 9]},
   {'kode': '2034', 'angka': [1, 5, 6, 7, 8, 9]},
   {'kode': '2940', 'angka': [1, 3, 5, 6, 7, 8]}]},
 {'tanggal': '30 Mei 2026',
  'waktu': '06:30',
  'daftar_prize': [{'kode': '4049', 'angka': [1, 2, 3, 5, 6, 7, 8]},
   {'kode': '6606', 'angka': [1, 2, 3, 4, 5, 7, 8, 9]},
   {'kode': '0339', 'angka': [1, 2, 4, 5, 6, 7, 8]},
   {'kode': '7823', 'angka': [0, 1, 4, 5, 6, 9]},
   {'kode': '1254', 'angka': [0, 3, 6, 7, 8, 9]},
   {'kode': '6841', 'angka': [0, 2, 3, 5, 7, 9]},
   {'kode': '5917', 'angka': [0, 2, 3, 4, 6, 8]},
   {'kode': '7261', 'angka': [0, 3, 4, 5, 8, 9]},
   {'kode': '3955', 'angka': [0, 1, 2, 4, 6, 7, 8]},
   {'kode': '7657', 'angka': [0, 1, 2, 3, 4, 8, 9]},
   {'kode': '4269', 'angka': [0, 1, 3, 5, 7, 8]},
   {'kode': '1604', 'angka': [2, 3, 5, 7, 8, 9]},
   {'kode': '1555', 'angka': [0, 2, 3, 4, 6, 7, 8, 9]}]}]

python
from datetime import datetime, timedelta
months = {
    "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_date(tgl, waktu):
    parts=tgl.split()
    day=int(parts[0]); month=months[parts[1]]; year=int(parts[2])
    h,m=map(int,waktu.split(":"))
    return datetime(year, month, day, h, m)
records=[]
for si,s in enumerate(data):
    dt=parse_date(s['tanggal'], s['waktu'])
    for pi,p in enumerate(s['daftar_prize'], start=1):
        code=str(p['kode']).zfill(4)
        records.append({"session_idx":si, "dt":dt, "tanggal":s['tanggal'], "waktu":s['waktu'], "prize":pi, "kode":code, "angka":p['angka']})
df=pd.DataFrame(records)
print(df.shape)
print(df['prize'].nunique(), df.groupby('session_idx').size().value_counts())
print(df['waktu'].unique())
print(df.groupby('waktu')['session_idx'].nunique())
print(df['dt'].min(), df['dt'].max())
print(df.tail(13)[['dt','waktu','prize','kode']].to_string(index=False))
# validate angka complement
def complement(code):
    return sorted(set(range(10))-set(map(int, code)))
bad=[]
for _,r in df.iterrows():
    if sorted(r['angka']) != complement(r['kode']):
        bad.append((r['dt'], r['prize'], r['kode'], r['angka'], complement(r['kode'])))
len(bad), bad[:3]


(0, [])

python
import json, os, math, itertools, pandas as pd, numpy as np
from datetime import datetime, timedelta

path='/mnt/data/data_ekstraksi.json'
with open(path,'r',encoding='utf-8') as f:
    data=json.load(f)

months = {
    "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_date(tgl, waktu):
    parts=tgl.split()
    day=int(parts[0]); month=months[parts[1]]; year=int(parts[2])
    h,m=map(int,waktu.split(":"))
    return datetime(year, month, day, h, m)

session_rows=[]
records=[]
for si,s in enumerate(data):
    dt=parse_date(s['tanggal'], s['waktu'])
    session_rows.append({"session_idx":si, "dt":dt, "tanggal":s['tanggal'], "waktu":s['waktu'], "n_prize":len(s['daftar_prize'])})
    for pi,p in enumerate(s['daftar_prize'], start=1):
        code=str(p['kode']).zfill(4)
        records.append({"session_idx":si, "dt":dt, "tanggal":s['tanggal'], "waktu":s['waktu'], "prize":pi, "kode":code, "angka":p.get('angka')})
sessions=pd.DataFrame(session_rows)
df=pd.DataFrame(records)
sessions=sessions.sort_values("dt").reset_index(drop=True)
# The session_idx already chronological? Yes likely, but map to chrono_idx
idx_map={old:i for i,old in enumerate(sessions['session_idx'])}
sessions['chrono_idx']=sessions.index
df['chrono_idx']=df['session_idx'].map(idx_map)
df=df.sort_values(['chrono_idx','prize']).reset_index(drop=True)

schedule=["03:30","06:30","11:30","13:30","17:30","21:30"]
last_s=sessions.iloc[-1]
last_dt=last_s['dt']; last_time=last_s['waktu']
next_time = schedule[(schedule.index(last_time)+1)%len(schedule)]
h,m=map(int,next_time.split(":"))
next_date = last_dt.date()
if schedule.index(next_time) <= schedule.index(last_time):
    next_date = (last_dt + timedelta(days=1)).date()
target_dt = datetime.combine(next_date, datetime.min.time()).replace(hour=h, minute=m)
print("sessions", len(sessions), "records", len(df), "last", last_dt, last_time, "next", target_dt, next_time)

digits=list('0123456789')

def digit_probs_for_prize(train_df, train_sessions, prize, pos, target_time, prev_code=None, alpha=0.35):
    """
    Returns probabilities for digits 0-9 at a single position for a prize.
    """
    # recency: use chrono_idx max
    maxidx = train_df['chrono_idx'].max()
    sub = train_df[(train_df['prize']==prize)].copy()
    # If no data, uniform
    def weighted_counts(rows, half_life=80):
        counts=np.ones(10)*alpha
        if rows.empty:
            return counts
        ages = maxidx - rows['chrono_idx'].values
        weights = np.exp(-np.log(2)*ages/half_life)
        for code, w in zip(rows['kode'].values, weights):
            counts[int(code[pos])] += w
        return counts
    # Global for this prize/position
    c_global = weighted_counts(sub, half_life=110)
    # Same target time
    c_time = weighted_counts(sub[sub['waktu']==target_time], half_life=45)
    # Recent sessions for this prize
    c_recent = weighted_counts(sub.tail(35), half_life=20)
    # All prizes same position, target time (adds cross-sectional stability)
    allpos = train_df.copy()
    c_all_time = weighted_counts(allpos[allpos['waktu']==target_time].assign(prize=prize), half_life=45)
    
    # Transition from prev_code same position: observed next digit after last time -> target time, same prize
    c_trans=np.ones(10)*alpha
    if prev_code is not None:
        prev_digit=prev_code[pos]
        # Pairs from consecutive sessions historically where previous time -> target_time
        rows=[]
        # use train_sessions chronological, from i=1 to len-1, current time target_time, previous session has prev_digit for prize at pos
        code_by_idx_prize = {(r.chrono_idx, r.prize):r.kode for r in train_df.itertuples()}
        for ci in range(1, int(train_sessions['chrono_idx'].max())+1):
            curr = train_sessions[train_sessions['chrono_idx']==ci].iloc[0]
            if curr['waktu'] != target_time:
                continue
            prev = train_sessions[train_sessions['chrono_idx']==ci-1].iloc[0]
            pc = code_by_idx_prize.get((ci-1, prize))
            cc = code_by_idx_prize.get((ci, prize))
            if pc and cc and pc[pos] == prev_digit:
                age = maxidx - ci
                w = math.exp(-math.log(2)*age/50)
                c_trans[int(cc[pos])] += w
        # If there are too few, fallback to all previous digit transitions independent of target time
        if c_trans.sum() < 10*alpha + 1e-9:
            pass
    # Combine normalized
    comps=[]
    weights=[]
    for c,w in [(c_global,0.24),(c_time,0.32),(c_recent,0.20),(c_all_time,0.10),(c_trans,0.14)]:
        p=c/c.sum()
        comps.append(p); weights.append(w)
    probs=sum(w*p for w,p in zip(weights,comps))
    probs=probs/probs.sum()
    return probs

def predict_for_prize(train_df, train_sessions, prize, target_time, prev_code=None, topn=10):
    pos_probs=[digit_probs_for_prize(train_df, train_sessions, prize, pos, target_time, prev_code=prev_code) for pos in range(4)]
    # Generate top candidates across all 10^4 combos
    # small penalties/bonuses for repeat-pattern based on historical same prize/time
    hist = train_df[(train_df['prize']==prize)&(train_df['waktu']==target_time)]
    # distributions for number of unique digits
    uniq_counts = hist['kode'].apply(lambda x: len(set(x))).value_counts(normalize=True).to_dict()
    # repeat positions maybe no need
    candidates=[]
    for combo in itertools.product(range(10), repeat=4):
        code=''.join(map(str,combo))
        logp=sum(math.log(pos_probs[pos][combo[pos]]+1e-15) for pos in range(4))
        # Pattern prior: probability of unique count with Laplace
        u=len(set(code))
        pat=(uniq_counts.get(u,0)+0.1)/(1+0.4)  # smoothing small
        # Slight code recency penalty if exact appeared in latest 20 same prize (reduce duplicates a bit, not eliminate)
        recent_codes=set(train_df[train_df['prize']==prize].tail(20)['kode'])
        if code in recent_codes:
            logp += math.log(0.80)
        logp += 0.15*math.log(pat)
        candidates.append((code, math.exp(logp)))
    candidates.sort(key=lambda x:x[1], reverse=True)
    top=candidates[:topn]
    # normalize among all? Use raw relative; convert top prob percentages normalized over 10000 score sum
    total=sum(s for _,s in candidates)
    top=[(c, s/total) for c,s in top]
    return top, pos_probs

train_df=df.copy()
train_sessions=sessions.copy()
last_codes={r.prize:r.kode for r in train_df[train_df['chrono_idx']==train_df['chrono_idx'].max()].itertuples()}
preds=[]
pos_prob_agg=np.zeros(10)
for prize in range(1,14):
    top,pos_probs=predict_for_prize(train_df, train_sessions, prize, next_time, prev_code=last_codes.get(prize), topn=10)
    preds.append({"prize":prize, "main":top[0][0], "alternatives":[c for c,_ in top[1:6]], "top10":top})
    for pp in pos_probs:
        pos_prob_agg += pp

preds[:3], preds[-1]

python
import json, os, math, itertools
from datetime import datetime, timedelta
import numpy as np
import pandas as pd

path='/mnt/data/data_ekstraksi.json'
with open(path,'r',encoding='utf-8') as f:
    data=json.load(f)

months={"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_dt(tgl,waktu):
    day, mon, year = tgl.split()
    h,m=map(int,waktu.split(':'))
    return datetime(int(year), months[mon], int(day), h, m)

# sort chronologically just in case
sessions_raw=[]
for s in data:
    sessions_raw.append((parse_dt(s['tanggal'],s['waktu']), s))
sessions_raw.sort(key=lambda x:x[0])
N=len(sessions_raw)
P=max(len(s['daftar_prize']) for _,s in sessions_raw)
codes=np.empty((N,P), dtype

python
# Backtest last 80 target sessions; each target session ti is predicted from data[:ti]
def predict_prize_train(p, target_time, train_end, topn=20):
    prev_code=codes[train_end-1,p]
    probs=[digit_probs(p,pos,target_time,prev_code,train_end) for pos in range(4)]
    scores=np.ones(10000)
    for pos in range(4):
        scores *= probs[pos][combos[:,pos]]
    idx_time=np.where(time_arr[:train_end]==target_time)[0]
    unique_counts=np.ones(5)*0.1
    for idx in idx_time:
        u=len(set(codes[idx,p]))
        unique_counts[u] += 1
    unique_probs=unique_counts/unique_counts.sum()
    scores *= (unique_probs[combo_unique] ** 0.15)
    recent_set=set(codes[max(0,train_end-20):train_end,p])
    if recent_set:
        mask=np.isin(combo_codes, list(recent_set))
        scores[mask]*=0.80
    order=np.argsort(scores)[::-1][:topn]
    return [str(combo_codes[i]) for i in order], probs

test_start=max(60, N-80)
n_cases=0; exact1=0; exact5=0; exact10=0; exact20=0; pos_correct=0; digitset_hit=0
bypos=np.zeros(4,int); bypos_total=np.zeros(4,int)
for ti in range(test_start, N):
    target_time=times[ti]
    for p in range(P):
        tops, probs = predict_prize_train(p,target_time,ti,topn=20)
        actual=codes[ti,p]
        n_cases+=1
        if actual==tops[0]: exact1+=1
        if actual in tops[:5]: exact5+=1
        if actual in tops[:10]: exact10+=1
        if actual in tops[:20]: exact20+=1
        pred=tops[0]
        for pos in range(4):
            if actual[pos]==pred[pos]:
                pos_correct+=1; bypos[pos]+=1
            bypos_total[pos]+=1
        # if top BBFS? check if all unique actual digits in aggregate of top prediction? we'll not
print("cases", n_cases, "exact1", exact1, exact5, exact10, exact20, 
      "exact rates", [x/n_cases for x in [exact1,exact5,exact10,exact20]],
      "posacc", pos_correct/(n_cases*4), "bypos", bypos/bypos_total)

python
from pathlib import Path
import csv

# Membuat file script Google Colab yang bisa dipakai ulang dengan data JSON serupa.
script = r'''
# ============================================================
# PREDIKSI NEXT PRIZE DARI data_ekstraksi.json
# Cocok dijalankan di Google Colab
# ============================================================

import json, math, itertools
from datetime import datetime, timedelta
from pathlib import Path

import numpy as np
import pandas as pd

# ------------------------------------------------------------
# 1) Upload file JSON di Colab
# ------------------------------------------------------------
try:
    from google.colab import files
    uploaded = files.upload()
    if not uploaded:
        raise RuntimeError("Tidak ada file yang diupload.")
    JSON_PATH = next(iter(uploaded.keys()))
except Exception:
    # Untuk jalan lokal: ubah path ini sesuai lokasi file Anda.
    JSON_PATH = "data_ekstraksi.json"

print("File dipakai:", JSON_PATH)

# ------------------------------------------------------------
# 2) Load dan parse data
# ------------------------------------------------------------
with open(JSON_PATH, "r", encoding="utf-8") as f:
    data = json.load(f)

MONTHS_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_dt(tanggal, waktu):
    hari, bulan, tahun = tanggal.split()
    jam, menit = map(int, waktu.split(":"))
    return datetime(int(tahun), MONTHS_ID[bulan], int(hari), jam, menit)

sessions_raw = []
for s in data:
    sessions_raw.append((parse_dt(s["tanggal"], s["waktu"]), s))
sessions_raw.sort(key=lambda x: x[0])

N = len(sessions_raw)
P = max(len(s["daftar_prize"]) for _, s in sessions_raw)

codes = np.empty((N, P), dtype=object)
times = []
dts = []

for i, (dt, s) in enumerate(sessions_raw):
    dts.append(dt)
    times.append(s["waktu"])
    if len(s["daftar_prize"]) != P:
        raise ValueError(f"Sesi ke-{i} punya jumlah prize berbeda: {len(s['daftar_prize'])}")
    for p in range(P):
        codes[i, p] = str(s["daftar_prize"][p]["kode"]).zfill(4)

digit_arr = np.zeros((N, P, 4), dtype=np.int8)
for i in range(N):
    for p in range(P):
        digit_arr[i, p, :] = [int(ch) for ch in codes[i, p]]

time_arr = np.array(times)

# Validasi angka pelengkap jika field "angka" tersedia
bad_complement = 0
for i, (_, s) in enumerate(sessions_raw):
    for p, prize in enumerate(s["daftar_prize"]):
        if "angka" in prize:
            kode = str(prize["kode"]).zfill(4)
            complement = sorted(set(range(10)) - set(map(int, kode)))
            if sorted(prize["angka"]) != complement:
                bad_complement += 1

print(f"Jumlah sesi      : {N}")
print(f"Jumlah prize/sesi: {P}")
print(f"Total kode       : {N * P}")
print(f"Data pertama     : {dts[0]}")
print(f"Data terakhir    : {dts[-1]}")
print(f"Validasi angka pelengkap bermasalah: {bad_complement}")

# ------------------------------------------------------------
# 3) Tentukan sesi berikutnya
# ------------------------------------------------------------
SCHEDULE = ["03:30", "06:30", "11:30", "13:30", "17:30", "21:30"]

last_dt = dts[-1]
last_time = times[-1]
next_time = SCHEDULE[(SCHEDULE.index(last_time) + 1) % len(SCHEDULE)]

hour, minute = map(int, next_time.split(":"))
next_date = last_dt.date()
if SCHEDULE.index(next_time) <= SCHEDULE.index(last_time):
    next_date = (last_dt + timedelta(days=1)).date()

target_dt = datetime.combine(next_date, datetime.min.time()).replace(hour=hour, minute=minute)

print(f"Target prediksi  : {target_dt.strftime('%d-%m-%Y %H:%M')}")

# ------------------------------------------------------------
# 4) Model prediksi statistik
# ------------------------------------------------------------
combos = np.array(list(itertools.product(range(10), repeat=4)), dtype=np.int8)
combo_codes = np.array(["".join(map(str, c)) for c in combos])
combo_unique = np.array([len(set(code)) for code in combo_codes])

def weighted_counts_indices(indices, p, pos, half_life, maxidx, alpha=0.35):
    counts = np.ones(10) * alpha
    if len(indices) == 0:
        return counts
    ages = maxidx - indices
    weights = np.exp(-np.log(2) * ages / half_life)
    vals = digit_arr[indices, p, pos]
    for v, w in zip(vals, weights):
        counts[v] += w
    return counts

def digit_probs(p, pos, target_time, prev_code=None, train_end=None):
    if train_end is None:
        train_end = N
    maxidx = train_end - 1

    idx_all = np.arange(train_end)
    idx_time = np.where(time_arr[:train_end] == target_time)[0]
    idx_recent = np.arange(max(0, train_end - 35), train_end)

    # Komponen 1: frekuensi digit posisi untuk prize yang sama
    c_global = weighted_counts_indices(idx_all, p, pos, 110, maxidx)

    # Komponen 2: frekuensi digit pada jam target yang sama
    c_time = weighted_counts_indices(idx_time, p, pos, 45, maxidx)

    # Komponen 3: data terbaru
    c_recent = weighted_counts_indices(idx_recent, p, pos, 20, maxidx)

    # Komponen 4: semua prize pada jam target, untuk stabilisasi
    c_alltime = np.ones(10) * 0.35
    if len(idx_time) > 0:
        for pp in range(P):
            c_alltime += weighted_counts_indices(idx_time, pp, pos, 45, maxidx, alpha=0.0)

    # Komponen 5: transisi dari sesi sebelumnya ke jam target
    c_trans = np.ones(10) * 0.35
    if prev_code is not None:
        prev_digit = int(prev_code[pos])
        for ci in range(1, train_end):
            if time_arr[ci] == target_time and digit_arr[ci - 1, p, pos] == prev_digit:
                age = maxidx - ci
                c_trans[digit_arr[ci, p, pos]] += math.exp(-math.log(2) * age / 50)

    comps = [
        c_global / c_global.sum(),
        c_time / c_time.sum(),
        c_recent / c_recent.sum(),
        c_alltime / c_alltime.sum(),
        c_trans / c_trans.sum(),
    ]
    weights = [0.24, 0.32, 0.20, 0.10, 0.14]
    probs = sum(w * c for w, c in zip(weights, comps))
    return probs / probs.sum()

def predict_prize(p, target_time, train_end=None, topn=20):
    if train_end is None:
        train_end = N

    prev_code = codes[train_end - 1, p]
    probs = [digit_probs(p, pos, target_time, prev_code, train_end) for pos in range(4)]

    scores = np.ones(10000)
    for pos in range(4):
        scores *= probs[pos][combos[:, pos]]

    # Prior pola: jumlah digit unik di jam target
    idx_time = np.where(time_arr[:train_end] == target_time)[0]
    unique_counts = np.ones(5) * 0.1
    for idx in idx_time:
        u = len(set(codes[idx, p]))
        unique_counts[u] += 1
    unique_probs = unique_counts / unique_counts.sum()
    scores *= unique_probs[combo_unique] ** 0.15

    # Penalti kecil untuk kode exact yang baru muncul di prize yang sama
    recent_set = set(codes[max(0, train_end - 20):train_end, p])
    if recent_set:
        scores[np.isin(combo_codes, list(recent_set))] *= 0.80

    order = np.argsort(scores)[::-1][:topn]
    total = scores.sum()

    return [(str(combo_codes[i]), float(scores[i] / total)) for i in order], probs

# ------------------------------------------------------------
# 5) Backtest sederhana pada 80 sesi terakhir
# ------------------------------------------------------------
def backtest(last_n_sessions=80):
    test_start = max(60, N - last_n_sessions)
    n_cases = exact1 = exact5 = exact10 = exact20 = pos_correct = 0

    for ti in range(test_start, N):
        target_time = times[ti]
        for p in range(P):
            tops, _ = predict_prize(p, target_time, train_end=ti, topn=20)
            pred_list = [x[0] for x in tops]
            actual = codes[ti, p]

            n_cases += 1
            exact1 += int(actual == pred_list[0])
            exact5 += int(actual in pred_list[:5])
            exact10 += int(actual in pred_list[:10])
            exact20 += int(actual in pred_list[:20])

            pred = pred_list[0]
            pos_correct += sum(actual[i] == pred[i] for i in range(4))

    return {
        "cases": n_cases,
        "exact_top1": exact1,
        "exact_top5": exact5,
        "exact_top10": exact10,
        "exact_top20": exact20,
        "exact_top1_rate": exact1 / n_cases if n_cases else 0,
        "exact_top20_rate": exact20 / n_cases if n_cases else 0,
        "pos_digit_accuracy": pos_correct / (n_cases * 4) if n_cases else 0,
    }

bt = backtest(80)

print("\nBacktest 80 sesi terakhir")
print("-------------------------")
print(f"Jumlah kasus          : {bt['cases']}")
print(f"Exact Top-1           : {bt['exact_top1']} ({bt['exact_top1_rate']:.4%})")
print(f"Exact Top-20          : {bt['exact_top20']} ({bt['exact_top20_rate']:.4%})")
print(f"Akurasi posisi digit  : {bt['pos_digit_accuracy']:.4%}")

# ------------------------------------------------------------
# 6) Buat prediksi final
# ------------------------------------------------------------
rows = []
digit_score = np.zeros(10)

for p in range(P):
    top, probs = predict_prize(p, next_time, train_end=N, topn=20)

    for pr in probs:
        digit_score += pr

    rows.append({
        "target_datetime": target_dt.strftime("%Y-%m-%d %H:%M"),
        "prize": p + 1,
        "prediksi_utama": top[0][0],
        "alternatif_1": top[1][0],
        "alternatif_2": top[2][0],
        "alternatif_3": top[3][0],
        "alternatif_4": top[4][0],
        "alternatif_5": top[5][0],
        "top10": ", ".join(x[0] for x in top[:10]),
        "score_relatif_top1": top[0][1],
        "angka_string_prediksi": ",".join(str(d) for d in sorted(set(range(10)) - set(map(int, top[0][0])))),
    })

result = pd.DataFrame(rows)
bbfs_digits = [str(i) for i in np.argsort(digit_score)[::-1][:7]]
bbfs = "".join(bbfs_digits)

print("\nPrediksi final")
print("--------------")
print("Target:", target_dt.strftime("%d-%m-%Y %H:%M"))
print("BBFS  :", bbfs)
print(result[["prize", "prediksi_utama", "alternatif_1", "alternatif_2", "alternatif_3", "alternatif_4", "alternatif_5", "angka_string_prediksi"]].to_string(index=False))

out_csv = "prediksi_next_prize_json.csv"
result.to_csv(out_csv, index=False)
print(f"\nFile hasil disimpan: {out_csv}")

try:
    from google.colab import files
    files.download(out_csv)
except Exception:
    pass
'''

out_path = Path("/mnt/data/prediksi_prize_json_colab.py")
out_path.write_text(script, encoding="utf-8")

# Juga buat CSV hasil prediksi dari run saat ini agar bisa diunduh langsung.
rows = [
    [1, "5698", "7698, 9698, 5658, 7658, 9658", "1,2,3,4,7"],
    [2, "5937", "5935, 5932, 5939, 5907, 5905", "0,1,2,4,6,8"],
    [3, "5851", "5831, 5857, 5837, 5531, 7851", "0,2,3,4,6,7,9"],
    [4, "9593", "9573, 6593, 6573, 9523, 7593", "0,1,2,4,6,7,8"],
    [5, "4139", "4130, 4339, 4169, 4330, 4160", "0,2,5,6,7,8"],
    [6, "0781", "0581, 0785, 0281, 0181, 0787", "2,3,4,5,6,9"],
    [7, "9711", "9011, 9511, 9611, 9714, 9917", "0,2,3,4,5,6,8"],
    [8, "5534", "3534, 2534, 7534, 5537, 5532", "0,1,2,6,7,8,9"],
    [9, "3709", "3700, 3770, 3779, 3707, 3705", "1,2,4,5,6,8"],
    [10, "2736", "4736, 2136, 2735, 4136, 8736", "0,1,4,5,8,9"],
    [11, "1664", "1674, 1624, 1264, 1604, 1274", "0,2,3,5,7,8,9"],
    [12, "0636", "0106, 0603, 0706, 0136, 0633", "1,2,4,5,7,8,9"],
    [13, "9872", "9072, 9572, 9972, 9372, 9172", "0,1,3,4,5,6"],
]
csv_path = Path("/mnt/data/prediksi_next_prize_json.csv")
with csv_path.open("w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["prize", "prediksi_utama", "alternatif_kuat", "angka_string_prediksi"])
    writer.writerows(rows)

print(f"Script Colab dibuat: {out_path}")
print(f"CSV hasil prediksi dibuat: {csv_path}")

python
import json, math, itertools, os, sys, statistics, textwrap, csv
from pathlib import Path
import numpy as np, pandas as pd
path='/mnt/data/data_ekstraksi.json'
print(os.path.exists(path), os.path.getsize(path))
data=json.load(open(path,encoding='utf-8'))
len(data), data[0].keys(), len(data[0]['daftar_prize'])


(645, dict_keys(['tanggal', 'waktu', 'daftar_prize']), 13)

python
MONTHS_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
}
from datetime import datetime, timedelta
def parse_dt(tanggal, waktu):
    hari, bulan, tahun = tanggal.split()
    jam, menit = map(int, waktu.split(':'))
    return datetime(int(tahun), MONTHS_ID[bulan], int(hari), jam, menit)
sessions=sorted([(parse_dt(s['tanggal'], s['waktu']), s) for s in data], key=lambda x:x[0])
N=len(sessions); P=13
times=[]; dts=[]; codes=np.empty((N,P),dtype=object)
for i,(dt,s) in enumerate(sessions):
    dts.append(dt); times.append(s['waktu'])
    for p,pr in enumerate(s['daftar_prize']):
        codes[i,p]=str(pr['kode']).zfill(4)
time_arr=np.array(times)
digit_arr=np.array([[[int(ch) for ch in codes[i,p]] for p in range(P)] for i in range(N)], dtype=np.int8)
dts[0], dts[-1], times[-1], codes[-1,0]


(datetime.datetime(2026, 2, 10, 21, 30),
 datetime.datetime(2026, 5, 30, 6, 30),
 '06:30',
 '4049')

python
SCHEDULE=["03:30","06:30","11:30","13:30","17:30","21:30"]
last_dt=dts[-1]; last_time=times[-1]; next_time=SCHEDULE[(SCHEDULE.index(last_time)+1)%len(SCHEDULE)]
next_date=last_dt.date()
if SCHEDULE.index(next_time)<=SCHEDULE.index(last_time):
    next_date=(last_dt+timedelta(days=1)).date()
target_dt=datetime.combine(next_date, datetime.min.time()).replace(hour=int(next_time.split(':')[0]), minute=int(next_time.split(':')[1]))
target_dt


datetime.datetime(2026, 5, 30, 11, 30)

python
combos = np.array(list(itertools.product(range(10), repeat=4)), dtype=np.int8)
combo_codes=np.array(["".join(map(str,c)) for c in combos])
combo_unique=np.array([len(set(code)) for code in combo_codes])
combo_max_count=np.array([max(code.count(str(d)) for d in range(10)) for code in combo_codes])
has_kembar=combo_max_count>=2
def weighted_counts_indices(indices, p, pos, half_life, maxidx, alpha=0.35):
    counts=np.ones(10)*alpha
    if len(indices)==0: return counts
    ages=maxidx-indices
    weights=np.exp(-np.log(2)*ages/half_life)
    vals=digit_arr[indices,p,pos]
    for v,w in zip(vals,weights): counts[v]+=w
    return counts
def digit_probs(p, pos, target_time, prev_code=None, train_end=None):
    if train_end is None: train_end=N
    maxidx=train_end-1
    idx_all

(array([0.39526188, 0.39814505, 0.33403008, 0.33040065, 0.39364425,
        0.44509624, 0.41529814, 0.41421015, 0.39534754, 0.47856601]),
 ['9', '5', '6', '7', '1', '8', '0'],
 ['9', '5', '6', '7', '1', '8', '0', '4'],
 ['9', '5', '6', '7', '1', '8', '0', '4', '2', '3'])

python
idx_time=np.where(time_arr==next_time)[0]
hist_prize1_time=[codes[i,0] for i in idx_time]
from collections import Counter, defaultdict
unique_count=Counter(len(set(c)) for c in hist_prize1_time)
unique_count, len(hist_prize1_time), hist_prize1_time[-10:]


(Counter({4: 54, 3: 51, 2: 3}),
 108,
 ['7359',
  '8791',
  '4654',
  '9249',
  '1494',
  '5693',
  '9757',
  '0678',
  '5608',
  '7990'])

python
from collections import Counter
# kembar score
def kembar_scores_for_prize(p=0, target_time=next_time, train_end=N):
    maxidx=train_end-1
    scores=np.ones(10)*0.1
    # all prize 1 weighted repeats
    for i in range(train_end):
        age=maxidx-i
        w=math.exp(-math.log(2)*age/90)
        c=Counter(codes[i,p])
        for dstr,cnt in c.items():
            if cnt>=2:
                scores[int(dstr)] += w*(cnt-1)
    # target time weighted repeats stronger
    for i in np.where(time_arr[:train_end]==target_time)[0]:
        age=maxidx-i
        w=math.exp(-math.log(2)*age/45)
        c=Counter(codes[i,p])
        for dstr,cnt in c.items():
            if cnt>=2:
                scores[int(dstr)] += 1.5*w*(cnt-1)
    # last 30 repeats
    for i in range(max(0,train_end-30), train_end):
        age=maxidx-i
        w=math.exp(-math.log(2)*age/15)
        c=Counter(codes[i,p])
        for dstr,cnt in c.items():
            if cnt>=2:
                scores[int(dstr)] += 1.0*w*(cnt-1)
    scores=scores/scores.max()
    return scores
ks=kembar_scores_for_prize()
[(d,ks[d],digit_score[d]) for d in np.argsort(ks)[::-1]]


[(np.int64(4), np.float64(1.0), np.float64(0.39364425408161197)),
 (np.int64(1), np.float64(0.5785460318743447), np.float64(0.3981450469875175)),
 (np.int64(2), np.float64(0.5508521480069671), np.float64(0.3340300780764538)),
 (np.int64(9),
  np.float64(0.5076977145029216),
  np.float64(0.47856601368430324)),
 (np.int64(8),
  np.float64(0.49694138576162067),
  np.float64(0.39534754458645727)),
 (np.int64(7), np.float64(0.4802545156032401), np.float64(0.4142101469646493)),
 (np.int64(3), np.float64(0.4022164675127191), np.float64(0.3304006490470087)),
 (np.int64(5),
  np.float64(0.39636934092797443),
  np.float64(0.44509623884291216)),
 (np.int64(0), np.float64(0.3303874144202954), np.float64(0.3952618838390303)),
 (np.int64(6), np.float64(0.3251520056257602), np.float64(0.4152981438900561))]

python
bbfs_set=set(map(int,bbfs8))
def code_score(code, probs, ks, bbfs_set=None, require_kembar=False):
    digs=[int(ch) for ch in code]
    if bbfs_set is not None and not set(digs).issubset(bbfs_set):
        return 0
    cnt=Counter(code)
    if require_kembar and max(cnt.values()) < 2:
        return 0
    s=1.0
    for pos,d in enumerate(digs):
        s*=probs[pos][d]
    # bonus for repeated digits
    for dstr,c in cnt.items():
        if c>=2:
            d=int(dstr)
            s*= (1.0 + 0.90*ks[d]*(c-1))
    # Penalize too extreme quads, mild for triples
    maxc=max(cnt.values())
    if maxc==4:
        s*=0.45
    elif maxc==3:
        s*=0.72
    # bonus using 7 strongest BBFS only
    s *= 1.0 + 0.04*sum(1 for d in digs if d in set(map(int,bbfs7)))
    # penalize recent exact
    if code in set(codes[max(0,N-30):N,0]):
        s*=0.75
    return s

scores=[]
for code in combo_codes:
    sc=code_score(code,probs,ks,bbfs_set,require_kembar=True)
    if sc>0:
        scores.append((code,sc))
scores_sorted=sorted(scores,key=lambda x:x[1],reverse=True)
scores_sorted[:30]


[(np.str_('9698'), np.float64(0.0008715558975249444)),
 (np.str_('9696'), np.float64(0.0007918317981328293)),
 (np.str_('5658'), np.float64(0.0007464983173327588)),
 (np.str_('5656'), np.float64(0.0006782136482529077)),
 (np.str_('9494'), np.float64(0.0006187145477546674)),
 (np.str_('9697'), np.float64(0.0006157333377095553)),
 (np.str_('9694'), np.float64(0.0006139940062169489)),
 (np.str_('9690'), np.float64(0.0006133351588646869)),
 (np.str_('5699'), np.float64(0.0006092212577372335)),
 (np.str_('7697'), np.float64(0.0006079055107618311)),
 (np.str_('5696'), np.float64(0.0006019401752205342)),
 (np.str_('9898'), np.float64(0.0006012443736694818)),
 (np.str_('5644'), np.float64(0.0005954868803982419)),
 (np.str_('5598'), np.float64(0.0005941783178542863)),
 (np.str_('9691'), np.float64(0.0005866624255601324)),
 (np.str_('9598'), np.float64(0.0005761057487845899)),
 (np.str_('7699'), np.float64(0.0005524405972031514)),
 (np.str_('5998'), np.float64(0.0005476410668781676)),
 (np.str_('5599'), np.float64(0.0005463566211386492)),
 (np.str_('7696'), np.float64(0.0005458381263886058)),
 (np.str_('7644'), np.float64(0.0005399862917714152)),
 (np.str_('9644'), np.float64(0.000537667433953602)),
 (np.str_('5544'), np.float64(0.0005340394737950953)),
 (np.str_('5688'), np.float64(0.0005317203045215945)),
 (np.str_('5454'), np.float64(0.000529936599729037)),
 (np.str_('5657'), np.float64(0.0005273831567558307)),
 (np.str_('5654'), np.float64(0.0005258933979965796)),
 (np.str_('5650'), np.float64(0.0005253290871574936)),
 (np.str_('8698'), np.float64(0.000521867371786674)),
 (np.str_('9699'), np.float64(0.0005202597637132959))]