Prediksi yang akurat untuk hasil top 10 2D yang ak...

Saya tidak bisa menjamin akurat/jitu 100% karena hasil 2D bersifat acak. Namun dari data PRIZE.txt, saya olah secara statistik: frekuensi 2D, bobot terbaru, posisi puluhan–satuan, dan 300 data terakhir. File berisi hasil dari 10 Februari 2026 sampai 31 Mei 2026. (PRIZE.txt)

Prediksi Top 10 2D utama

Rank	2D	Skor	Frekuensi total	Muncul di 300 terakhir
1	91	0.8859	34	7
2	48	0.8855	29	7
3	76	0.8131	32	6
4	06	0.8116	28	7
5	49	0.7857	30	6
6	50	0.7311	22	9
7	19	0.7280	26	6
8	94	0.7171	30	5
9	13	0.6893	24	7
10	16	0.6839	27	4

BBFS 5D terkuat: 10475

Kalau ingin top 10 yang hanya memakai digit BBFS 10475, ambil ini:

50, 10, 57, 71, 11, 41, 45, 54, 07, 40

Backtest sederhana di data historis: top 10 model ini kena sekitar 11.0% dari data uji berjalan, dan 13.7% untuk 300 data terakhir. Jadi ini lebih tepat dipakai sebagai alat filter/statistik, bukan jaminan menang.

Script Google Colab

Copy-paste ini ke Colab, lalu upload file PRIZE.txt.

python
# ==========================================
# PREDIKSI 2D + BBFS 5D DARI FILE PRIZE.txt
# Fokus: hasil 2D = 2 digit terakhir angka 4D
# ==========================================

import re
import numpy as np
import pandas as pd
from collections import Counter, defaultdict
from google.colab import files

uploaded = files.upload()
filename = list(uploaded.keys())[0]

text = open(filename, "r", encoding="utf-8", errors="ignore").read()

records = []
current_date, current_time = None, None

for line in text.splitlines():
    m = re.match(r"Tanggal:\s*(.*?)\s*\|\s*Waktu:\s*(\d{2}:\d{2})", line)
    if m:
        current_date = m.group(1).strip()
        current_time = m.group(2).strip()
        continue

    m = re.match(r"^\s*(\d{4})\s+([0-9,\s]+)\s*$", line)
    if m and current_date:
        num = m.group(1)
        records.append({
            "tanggal": current_date,
            "waktu": current_time,
            "angka_4d": num,
            "2d": num[-2:],
            "puluhan": num[-2],
            "satuan": num[-1]
        })

df = pd.DataFrame(records)
df["idx"] = np.arange(len(df))

print("Total data angka:", len(df))
print("Data awal:", df.iloc[0]["tanggal"], df.iloc[0]["waktu"])
print("Data akhir:", df.iloc[-1]["tanggal"], df.iloc[-1]["waktu"])
display(df.tail(10))

# ==============================
# Parameter model
# ==============================

HALF_LIFE = 300      # makin kecil = makin fokus ke data terbaru
RECENT_N = 300       # data terakhir untuk tren pendek
TOP_N = 10

N = len(df)
df["weight"] = 0.5 ** ((N - 1 - df["idx"]) / HALF_LIFE)

pairs = [f"{i:02d}" for i in range(100)]

def minmax_dict(d):
    vals = list(d.values())
    mn, mx = min(vals), max(vals)
    if mx == mn:
        return {k: 0.0 for k in d}
    return {k: (v - mn) / (mx - mn) for k, v in d.items()}

# ==============================
# Skor 2D
# ==============================

all_count = Counter(df["2d"])
recent_count = Counter(df.tail(RECENT_N)["2d"])

weighted_pair = {
    p: float(df.loc[df["2d"] == p, "weight"].sum())
    for p in pairs
}

norm_all = minmax_dict({p: all_count[p] for p in pairs})
norm_recent = minmax_dict({p: recent_count[p] for p in pairs})
norm_weighted = minmax_dict(weighted_pair)

weighted_tens = {
    str(d): float(df.loc[df["puluhan"] == str(d), "weight"].sum())
    for d in range(10)
}
weighted_ones = {
    str(d): float(df.loc[df["satuan"] == str(d), "weight"].sum())
    for d in range(10)
}

all_tens = Counter(df["puluhan"])
all_ones = Counter(df["satuan"])

norm_weighted_tens = minmax_dict(weighted_tens)
norm_weighted_ones = minmax_dict(weighted_ones)
norm_all_tens = minmax_dict({str(d): all_tens[str(d)] for d in range(10)})
norm_all_ones = minmax_dict({str(d): all_ones[str(d)] for d in range(10)})

rows = []

for p in pairs:
    t, o = p[0], p[1]

    pos_score = (
        0.60 * ((norm_weighted_tens[t] + norm_weighted_ones[o]) / 2)
        + 0.40 * ((norm_all_tens[t] + norm_all_ones[o]) / 2)
    )

    score = (
        0.45 * norm_weighted[p]
        + 0.25 * norm_all[p]
        + 0.15 * norm_recent[p]
        + 0.15 * pos_score
    )

    rows.append({
        "2D": p,
        "score": score,
        "freq_total": all_count[p],
        f"freq_{RECENT_N}_terakhir": recent_count[p],
        "weighted_score": weighted_pair[p],
        "pos_score": pos_score
    })

rank_df = pd.DataFrame(rows).sort_values("score", ascending=False).reset_index(drop=True)
rank_df["rank"] = rank_df.index + 1

print("\n=== TOP 10 2D UTAMA ===")
display(rank_df[["rank", "2D", "score", "freq_total", f"freq_{RECENT_N}_terakhir"]].head(TOP_N))

# ==============================
# BBFS 5D
# ==============================

digit_weight = defaultdict(float)
digit_all = defaultdict(float)
digit_recent = Counter()

for i, row in df.iterrows():
    angka = row["angka_4d"]
    dua_d = row["2d"]

    # Semua posisi 4D
    for ch in angka:
        digit_all[ch] += 1
        digit_weight[ch] += row["weight"]

    # Tambahan bobot untuk fokus 2D
    for ch in dua_d:
        digit_all[ch] += 0.4
        digit_weight[ch] += 0.4 * row["weight"]

    # Tren terbaru
    if i >= len(df) - RECENT_N:
        for ch in angka + dua_d:
            digit_recent[ch] += 1

norm_digit_weight = minmax_dict({str(d): digit_weight[str(d)] for d in range(10)})
norm_digit_all = minmax_dict({str(d): digit_all[str(d)] for d in range(10)})
norm_digit_recent = minmax_dict({str(d): digit_recent[str(d)] for d in range(10)})

digit_rows = []

for d in map(str, range(10)):
    digit_score = (
        0.50 * norm_digit_weight[d]
        + 0.30 * norm_digit_all[d]
        + 0.20 * norm_digit_recent[d]
    )

    digit_rows.append({
        "digit": d,
        "score": digit_score,
        "freq_total": digit_all[d],
        f"freq_{RECENT_N}_terakhir": digit_recent[d]
    })

digit_df = pd.DataFrame(digit_rows).sort_values("score", ascending=False).reset_index(drop=True)
digit_df["rank"] = digit_df.index + 1

bbfs5 = "".join(digit_df.head(5)["digit"].tolist())

print("\n=== RANKING DIGIT ===")
display(digit_df[["rank", "digit", "score", "freq_total", f"freq_{RECENT_N}_terakhir"]])

print("\n=== BBFS 5D TERKUAT ===")
print(bbfs5)

# Top 2D yang hanya memakai digit BBFS
bbfs_set = set(bbfs5)
bbfs_pairs = rank_df[rank_df["2D"].apply(lambda x: set(x).issubset(bbfs_set))].head(10)

print("\n=== TOP 10 2D KHUSUS DARI BBFS ===")
display(bbfs_pairs[["rank", "2D", "score", "freq_total", f"freq_{RECENT_N}_terakhir"]])

# ==============================
# Backtest sederhana
# ==============================

def minmax_arr(a):
    a = np.asarray(a, dtype=float)
    mn, mx = a.min(), a.max()
    if mx == mn:
        return np.zeros_like(a)
    return (a - mn) / (mx - mn)

seq = np.array([int(x) for x in df["2d"]])
tens = seq // 10
ones = seq % 10
pair_idx = np.arange(100)

def rank_at(i, half_life=HALF_LIFE, recent_n=RECENT_N):
    hist = seq[:i]
    ht = tens[:i]
    ho = ones[:i]

    age = np.arange(i - 1, -1, -1, dtype=float)
    w = 0.5 ** (age / half_life)

    wc = np.bincount(hist, weights=w, minlength=100)
    ac = np.bincount(hist, minlength=100)
    rc = np.bincount(hist[max(0, i - recent_n):], minlength=100)

    wt = np.bincount(ht, weights=w, minlength=10)
    wo = np.bincount(ho, weights=w, minlength=10)
    at = np.bincount(ht, minlength=10)
    ao = np.bincount(ho, minlength=10)

    nwc = minmax_arr(wc)
    nac = minmax_arr(ac)
    nrc = minmax_arr(rc)
    nwt = minmax_arr(wt)
    nwo = minmax_arr(wo)
    nat = minmax_arr(at)
    nao = minmax_arr(ao)

    pos = (
        0.60 * ((nwt[pair_idx // 10] + nwo[pair_idx % 10]) / 2)
        + 0.40 * ((nat[pair_idx // 10] + nao[pair_idx % 10]) / 2)
    )

    score = 0.45 * nwc + 0.25 * nac + 0.15 * nrc + 0.15 * pos
    return np.argsort(score)[::-1]

start = 500
hits5 = hits10 = hits20 = total = 0

for i in range(start, len(seq)):
    pred = rank_at(i)
    actual = seq[i]
    total += 1
    hits5 += int(actual in pred[:5])
    hits10 += int(actual in pred[:10])
    hits20 += int(actual in pred[:20])

print("\n=== BACKTEST BERJALAN ===")
print("Total data uji:", total)
print("Hit Top 5 :", round(hits5 / total * 100, 2), "%")
print("Hit Top 10:", round(hits10 / total * 100, 2), "%")
print("Hit Top 20:", round(hits20 / total * 100, 2), "%")

Hasil dari data yang kamu upload saat ini: Top 10 utama = 91, 48, 76, 06, 49, 50, 19, 94, 13, 16 dan BBFS 5D = 10475.