Prediksi untuk hasil selanjutnya yang akurat dan j...

Question

Prediksi untuk hasil selanjutnya yang akurat dan jitu dan buatkan scriptnya untuk di jalankan di google colab

Answer 1

Saya sudah baca file data_ekstraksi.json; isinya 645 periode hasil, tiap periode ada 13 daftar_prize dengan kode 4 digit dan angka sebagai digit komplemen/angka yang tidak muncul di kode. (data_ekstraksi.json)

Catatan penting: hasil seperti ini tidak bisa diprediksi 100% akurat karena sifatnya acak. Jadi prediksi di bawah ini adalah prediksi statistik berbasis frekuensi, recency, pola posisi digit, dan pola pasangan digit, bukan jaminan menang.

Prediksi berikutnya dari data terakhir

Data terakhir di file: 30 Mei 2026 06:30
Periode selanjutnya yang diperkirakan: 30 Mei 2026 11:30

Digit kuat per posisi:

Posisi	Kandidat digit kuat
Ribuan	4, 5, 0, 1, 6
Ratusan	5, 6, 2, 7, 1
Puluhan	3, 7, 1, 9, 5
Satuan	9, 7, 4, 3, 1

BBFS / digit utama: 0 1 3 4 5 6 7 9

13 kandidat 4D prioritas:

Script Google Colab

Copy semua kode ini ke 1 cell Google Colab, lalu jalankan. Upload file data_ekstraksi.json saat diminta.

python
# ============================================
# PREDIKSI 4D BERBASIS DATA JSON
# Cocok dijalankan di Google Colab
# ============================================

import json
import math
import itertools
from collections import Counter
from datetime import datetime, timedelta
import numpy as np
import pandas as pd

# Untuk Google Colab
try:
    from google.colab import files
    uploaded = files.upload()
    FILE_PATH = list(uploaded.keys())[0]
except:
    FILE_PATH = "data_ekstraksi.json"

# =========================
# 1. Load data
# =========================

with open(FILE_PATH, "r", encoding="utf-8") as f:
    data = json.load(f)

bulan_map = {
    "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(tanggal, waktu):
    d, bulan, y = tanggal.split()
    hh, mm = waktu.split(":")
    return datetime(int(y), bulan_map[bulan], int(d), int(hh), int(mm))

rows = []

for draw_idx, item in enumerate(data):
    dt = parse_tanggal(item["tanggal"], item["waktu"])
    for prize_idx, prize in enumerate(item["daftar_prize"], start=1):
        kode = str(prize["kode"]).zfill(4)
        rows.append({
            "draw_idx": draw_idx,
            "prize": prize_idx,
            "datetime": dt,
            "tanggal": item["tanggal"],
            "waktu": item["waktu"],
            "kode": kode,
            "angka": prize.get("angka", [])
        })

df = pd.DataFrame(rows).sort_values(["datetime", "prize"]).reset_index(drop=True)

print("Total periode:", len(data))
print("Total kode:", len(df))
print("Data terakhir:", df.iloc[-1]["tanggal"], df.iloc[-1]["waktu"])

# =========================
# 2. Tentukan jadwal berikutnya
# =========================

SCHEDULE = ["03:30", "06:30", "11:30", "13:30", "17:30", "21:30"]

last_dt = df["datetime"].max()
last_time = df.iloc[-1]["waktu"]

next_time = SCHEDULE[(SCHEDULE.index(last_time) + 1) % len(SCHEDULE)]

if last_time == SCHEDULE[-1] and next_time == SCHEDULE[0]:
    next_date = last_dt.date() + timedelta(days=1)
else:
    next_date = last_dt.date()

next_dt = datetime.combine(
    next_date,
    datetime.strptime(next_time, "%H:%M").time()
)

print("Prediksi untuk periode berikutnya:", next_dt.strftime("%d-%m-%Y %H:%M"))

# =========================
# 3. Fungsi statistik
# =========================

def pattern_key(code):
    """
    Mengubah pola angka menjadi bentuk umum:
    4539 -> ABCD
    1555 -> ABBB
    1128 -> AABC
    """
    mapping = {}
    output = []

    for ch in code:
        if ch not in mapping:
            mapping[ch] = chr(ord("A") + len(mapping))
        output.append(mapping[ch])

    return "".join(output)

def pos_probs(subdf, decay=None, smooth=1.0):
    counts = [Counter() for _ in range(4)]

    if len(subdf) == 0:
        return [{str(d): 0.1 for d in range(10)} for _ in range(4)]

    if decay is None:
        for code in subdf["kode"]:
            for i, ch in enumerate(code):
                counts[i][ch] += 1
    else:
        n = len(subdf)
        for idx, code in enumerate(subdf["kode"]):
            w = decay ** (n - 1 - idx)
            for i, ch in enumerate(code):
                counts[i][ch] += w

    probs = []
    for c in counts:
        total = sum(c.values()) + smooth * 10
        probs.append({
            str(d): (c.get(str(d), 0) + smooth) / total
            for d in range(10)
        })

    return probs

def global_digit_probs(subdf, decay=None, smooth=1.0):
    c = Counter()

    if len(subdf) == 0:
        return {str(d): 0.1 for d in range(10)}

    if decay is None:
        for code in subdf["kode"]:
            for ch in code:
                c[ch] += 1
    else:
        n = len(subdf)
        for idx, code in enumerate(subdf["kode"]):
            w = decay ** (n - 1 - idx)
            for ch in code:
                c[ch] += w

    total = sum(c.values()) + smooth * 10

    return {
        str(d): (c.get(str(d), 0) + smooth) / total
        for d in range(10)
    }

def pair_probs(subdf, decay=None, smooth=0.5):
    c = Counter()

    if len(subdf) == 0:
        return {f"{a}{b}": 0.01 for a in range(10) for b in range(10)}

    if decay is None:
        for code in subdf["kode"]:
            for i in range(3):
                c[code[i:i+2]] += 1
    else:
        n = len(subdf)
        for idx, code in enumerate(subdf["kode"]):
            w = decay ** (n - 1 - idx)
            for i in range(3):
                c[code[i:i+2]] += w

    total = sum(c.values()) + smooth * 100

    return {
        f"{a}{b}": (c.get(f"{a}{b}", 0) + smooth) / total
        for a in range(10)
        for b in range(10)
    }

def pattern_probs(subdf, smooth=0.2):
    all_patterns = set(
        pattern_key("".join(p))
        for p in itertools.product("0123456789", repeat=4)
    )

    c = Counter(pattern_key(code) for code in subdf["kode"])
    total = sum(c.values()) + smooth * len(all_patterns)

    return {
        p: (c.get(p, 0) + smooth) / total
        for p in all_patterns
    }

def hamming(a, b):
    return sum(x != y for x, y in zip(a, b))

# =========================
# 4. Model prediksi
# =========================

def predict_codes(flat_df, target_waktu, top_n=13, candidate_pool=200):
    flat_df = flat_df.sort_values(["datetime", "prize"]).reset_index(drop=True)

    recent_df = flat_df.tail(360)
    same_time_df = flat_df[flat_df["waktu"] == target_waktu]

    p_recent = pos_probs(recent_df, decay=0.992, smooth=1.5)
    p_same = pos_probs(same_time_df, decay=0.995, smooth=1.5)
    p_overall = pos_probs(flat_df, decay=None, smooth=1.0)
    p_global = global_digit_probs(recent_df, decay=0.992, smooth=1.0)
    p_pair = pair_probs(recent_df, decay=0.995, smooth=0.5)
    p_pattern = pattern_probs(flat_df, smooth=0.2)

    recent_exact = set(flat_df.tail(13 * 8)["kode"])
    last_100 = set(flat_df.tail(100)["kode"])

    def score_code(code):
        eps = 1e-12
        score = 0.0

        for i, ch in enumerate(code):
            score += 0.45 * math.log(p_recent[i][ch] + eps)
            score += 0.30 * math.log(p_same[i][ch] + eps)
            score += 0.15 * math.log(p_overall[i][ch] + eps)
            score += 0.05 * math.log(p_global[ch] + eps)

        for i in range(3):
            score += 0.08 * math.log(p_pair[code[i:i+2]] + eps)

        score += 0.10 * math.log(p_pattern[pattern_key(code)] + eps)

        # Penalti ringan jika kode sudah sangat baru muncul,
        # agar kandidat lebih variatif.
        if code in recent_exact:
            score -= 0.60
        elif code in last_100:
            score -= 0.25

        return score

    all_codes = ["".join(p) for p in itertools.product("0123456789", repeat=4)]
    scored = [(code, score_code(code)) for code in all_codes]
    scored = sorted(scored, key=lambda x: x[1], reverse=True)

    # Ambil kandidat beragam, tidak terlalu mirip semua
    selected = []
    for code, score in scored[:candidate_pool]:
        if all(hamming(code, old_code) >= 2 for old_code, _ in selected):
            selected.append((code, score))
        if len(selected) >= top_n:
            break

    # Digit kuat per posisi
    combined_pos = []
    for i in range(4):
        raw = {}
        for d in "0123456789":
            raw[d] = (
                p_recent[i][d] ** 0.45
                * p_same[i][d] ** 0.30
                * p_overall[i][d] ** 0.15
                * p_global[d] ** 0.05
            )
        total = sum(raw.values())
        combined_pos.append({
            d: raw[d] / total
            for d in raw
        })

    top_pos_digits = {
        f"posisi_{i+1}": sorted(
            combined_pos[i].items(),
            key=lambda x: x[1],
            reverse=True
        )[:5]
        for i in range(4)
    }

    hot_digits = sorted(
        p_global.items(),
        key=lambda x: x[1],
        reverse=True
    )

    return selected, top_pos_digits, hot_digits

prediksi, top_pos_digits, hot_digits = predict_codes(
    df,
    target_waktu=next_time,
    top_n=13
)

# =========================
# 5. Tampilkan hasil
# =========================

print("\n=== DIGIT KUAT PER POSISI ===")
nama_posisi = ["Ribuan", "Ratusan", "Puluhan", "Satuan"]

for i, nama in enumerate(nama_posisi, start=1):
    digits = [d for d, p in top_pos_digits[f"posisi_{i}"]]
    print(f"{nama}: {', '.join(digits)}")

bbfs = [d for d, p in hot_digits[:8]]
print("\nBBFS / Digit utama:", " ".join(bbfs))

print("\n=== 13 KANDIDAT 4D PRIORITAS ===")
for rank, (code, score) in enumerate(prediksi, start=1):
    print(f"{rank:02d}. {code} | score: {score:.4f}")

# =========================
# 6. Optional: Backtest sederhana
# =========================

RUN_BACKTEST = True
BACKTEST_LAST_N_DRAWS = 60
TOP_N = 13

if RUN_BACKTEST:
    print("\n=== BACKTEST SEDERHANA ===")
    print("Catatan: hit dihitung jika salah satu kandidat top-N muncul di 13 prize periode target.")

    draw_ids = sorted(df["draw_idx"].unique())
    test_ids = draw_ids[-BACKTEST_LAST_N_DRAWS:]

    hits = 0
    total = 0

    for target_draw_idx in test_ids:
        train_df = df[df["draw_idx"] < target_draw_idx].copy()
        target_df = df[df["draw_idx"] == target_draw_idx].copy()

        if len(train_df) < 100 or len(target_df) == 0:
            continue

        target_waktu = target_df.iloc[0]["waktu"]
        actual_codes = set(target_df["kode"].tolist())

        preds, _, _ = predict_codes(
            train_df,
            target_waktu=target_waktu,
            top_n=TOP_N
        )

        pred_codes = set(code for code, score in preds)

        if len(pred_codes & actual_codes) > 0:
            hits += 1

        total += 1

    if total > 0:
        print(f"Periode diuji: {total}")
        print(f"Hit: {hits}")
        print(f"Hit rate: {hits / total * 100:.2f}%")
    else:
        print("Data belum cukup untuk backtest.")

Gunakan hasilnya sebagai alat analisis, bukan patokan pasti. Untuk meningkatkan kualitas, jalankan ulang script setiap kali ada hasil terbaru agar bobot recency ikut berubah.

Prediksi untuk hasil selanjutnya yang akurat dan j...

Domanda

Python

Python

Python

Python

Python

Python

Python

Python

Pensiero

Risposta

Prediksi berikutnya dari data terakhir

Script Google Colab

Condividi questa Q&A