Prediksi untuk hasil selanjutnya fokus TOP 100 4D ...

Question

Prediksi untuk hasil selanjutnya fokus TOP 100 4D terkuat dan buatkan scriptnya untuk di jalankan di google colab

Answer 1

Saya olah dari file data_ekstraksi.json: ada data tanggal, waktu, dan daftar_prize berisi kode 4D. Data terakhir yang terbaca adalah 30 Mei 2026 06:30, jadi fokus “hasil selanjutnya” saya arahkan ke slot 11:30. Ini analisis pola statistik, bukan jaminan hasil undian. (data_ekstraksi.json)

TOP 100 4D terkuat

text
01.4517  02.4557  03.7517  04.4577  05.4519  06.7557  07.7514  08.6217  09.6219  10.4579
11.4527  12.4574  13.6276  14.1294  15.4507  16.9517  17.4677  18.6294  19.8294  20.6214
21.6297  22.4217  23.2517  24.4514  25.7519  26.1574  27.6279  28.6277  29.6577  30.4576
31.4819  32.4573  33.0297  34.0514  35.0194  36.0577  37.4587  38.4817  39.9576  40.2294
41.6677  42.6077  43.7217  44.2217  45.4219  46.7577  47.4627  48.6579  49.0557  50.8214
51.0527  52.1514  53.7614  54.0294  55.4794  56.4714  57.4287  58.4297  59.0584  60.0517
61.6517  62.6213  63.6299  64.4697  65.5276  66.9557  67.0676  68.4571  69.0677  70.4617
71.2194  72.6284  73.7554  74.0574  75.7214  76.2557  77.9514  78.4674  79.2519  80.0524
81.7694  82.6274  83.4694  84.1594  85.6074  86.1694  87.9507  88.2219  89.8194  90.0576
91.4614  92.5217  93.9217  94.4227  95.6017  96.8276  97.7017  98.6178  99.4774  100.6271

Script Google Colab

Tempel script ini di Colab, lalu upload data_ekstraksi.json.

python
# =========================
# PREDIKSI TOP 100 4D
# Google Colab Script
# =========================

import json
import math
import itertools
from collections import Counter, defaultdict
from datetime import datetime

import numpy as np
import pandas as pd

# 1) Upload file JSON
try:
    from google.colab import files
    uploaded = files.upload()
    FILE_PATH = list(uploaded.keys())[0]
except Exception:
    # Kalau jalan lokal, ganti path ini sesuai lokasi file
    FILE_PATH = "data_ekstraksi.json"

# 2) Baca 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_dt(tanggal, waktu):
    # contoh tanggal: "10 Februari 2026"
    d, b, y = tanggal.split()
    hh, mm = waktu.split(":")
    return datetime(int(y), bulan_map[b], int(d), int(hh), int(mm))

# 3) Flatten data menjadi baris kode
rows = []
for draw_idx, item in enumerate(data):
    dt = parse_dt(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,
            "dt": dt,
            "tanggal": item["tanggal"],
            "waktu": item["waktu"],
            "prize_idx": prize_idx,
            "kode": kode
        })

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

# 4) Tentukan slot hasil selanjutnya
slots = sorted(df["waktu"].unique(), key=lambda s: tuple(map(int, s.split(":"))))
latest_dt = df["dt"].max()
latest_time = latest_dt.strftime("%H:%M")

if latest_time in slots:
    target_slot = slots[(slots.index(latest_time) + 1) % len(slots)]
else:
    target_slot = None

print("Total sesi:", df["draw_idx"].nunique())
print("Total kode:", len(df))
print("Data terakhir:", latest_dt)
print("Target slot berikutnya:", target_slot)

# 5) Fungsi scoring
def build_top100(df, target_slot=None, half_life=1800):
    df = df.copy().reset_index(drop=True)
    n = len(df)

    # Bobot recency: data terbaru lebih kuat
    idx = np.arange(n)
    w = np.exp(-(n - 1 - idx) / half_life)

    # Sedikit bobot tambahan untuk prize awal
    prize_weight = (
        1.0
        + np.where(df["prize_idx"].values == 1, 0.15, 0.0)
        + np.where(df["prize_idx"].values <= 3, 0.05, 0.0)
    )
    w = w * prize_weight
    df["w"] = w

    total_w = df["w"].sum()

    pos_counts = [defaultdict(float) for _ in range(4)]
    pair_pos = list(itertools.combinations(range(4), 2))
    triple_pos = list(itertools.combinations(range(4), 3))

    pair_counts = {p: defaultdict(float) for p in pair_pos}
    triple_counts = {p: defaultdict(float) for p in triple_pos}

    exact_weighted = defaultdict(float)
    exact_plain = Counter(df["kode"])

    for kode, wt in zip(df["kode"], df["w"]):
        exact_weighted[kode] += wt

        for i, d in enumerate(kode):
            pos_counts[i][d] += wt

        for p in pair_pos:
            key = "".join(kode[i] for i in p)
            pair_counts[p][key] += wt

        for p in triple_pos:
            key = "".join(kode[i] for i in p)
            triple_counts[p][key] += wt

    # Slot khusus, misalnya 11:30
    slot_df = df[df["waktu"] == target_slot].copy() if target_slot else df.iloc[0:0].copy()
    total_sw = slot_df["w"].sum() if len(slot_df) else 0

    slot_pos_counts = [defaultdict(float) for _ in range(4)]
    slot_pair_counts = {p: defaultdict(float) for p in pair_pos}

    for kode, wt in zip(slot_df["kode"], slot_df["w"]):
        for i, d in enumerate(kode):
            slot_pos_counts[i][d] += wt

        for p in pair_pos:
            key = "".join(kode[i] for i in p)
            slot_pair_counts[p][key] += wt

    alpha_pos = 1.0
    alpha_pair = 1.0
    alpha_triple = 0.5

    exact_max = max(exact_weighted.values()) if exact_weighted else 1
    plain_max = max(exact_plain.values()) if exact_plain else 1

    result = []

    for num in range(10000):
        kode = f"{num:04d}"

        # Skor posisi digit
        pos_log = 0.0
        for i, d in enumerate(kode):
            pos_log += math.log(
                (pos_counts[i].get(d, 0) + alpha_pos) /
                (total_w + 10 * alpha_pos)
            )

        # Skor pasangan posisi
        pair_log = 0.0
        for p in pair_pos:
            key = "".join(kode[i] for i in p)
            pair_log += math.log(
                (pair_counts[p].get(key, 0) + alpha_pair) /
                (total_w + 100 * alpha_pair)
            )

        # Skor triple posisi
        triple_log = 0.0
        for p in triple_pos:
            key = "".join(kode[i] for i in p)
            triple_log += math.log(
                (triple_counts[p].get(key, 0) + alpha_triple) /
                (total_w + 1000 * alpha_triple)
            )

        # Skor khusus slot berikutnya
        slot_log = 0.0
        if total_sw > 0:
            for i, d in enumerate(kode):
                slot_log += math.log(
                    (slot_pos_counts[i].get(d, 0) + alpha_pos) /
                    (total_sw + 10 * alpha_pos)
                )

            for p in pair_pos:
                key = "".join(kode[i] for i in p)
                slot_log += 0.65 * math.log(
                    (slot_pair_counts[p].get(key, 0) + alpha_pair) /
                    (total_sw + 100 * alpha_pair)
                )

        exact_recency = math.log1p(exact_weighted.get(kode, 0)) / math.log1p(exact_max)
        exact_freq = exact_plain.get(kode, 0) / plain_max

        result.append({
            "kode": kode,
            "pos_log": pos_log,
            "pair_log": pair_log,
            "triple_log": triple_log,
            "slot_log": slot_log,
            "freq": exact_plain.get(kode, 0),
            "weighted_freq": exact_weighted.get(kode, 0),
            "exact_recency": exact_recency,
            "exact_freq": exact_freq
        })

    score_df = pd.DataFrame(result)

    # Normalisasi z-score
    for col in ["pos_log", "pair_log", "triple_log", "slot_log"]:
        std = score_df[col].std()
        if std == 0:
            std = 1
        score_df[col + "_z"] = (score_df[col] - score_df[col].mean()) / std

    # Bobot final
    score_df["score_raw"] = (
        0.27 * score_df["pos_log_z"] +
        0.26 * score_df["pair_log_z"] +
        0.12 * score_df["triple_log_z"] +
        0.16 * score_df["slot_log_z"] +
        0.12 * score_df["exact_recency"] +
        0.07 * score_df["exact_freq"]
    )

    # Skala 0-100
    mn = score_df["score_raw"].min()
    mx = score_df["score_raw"].max()
    score_df["score"] = (score_df["score_raw"] - mn) / (mx - mn) * 100

    score_df = score_df.sort_values("score", ascending=False).reset_index(drop=True)
    score_df["rank"] = np.arange(1, len(score_df) + 1)

    return score_df[[
        "rank", "kode", "score", "freq", "weighted_freq",
        "exact_recency", "exact_freq"
    ]].head(100)

# 6) Jalankan prediksi
top100 = build_top100(df, target_slot=target_slot)

pd.set_option("display.max_rows", 120)
print("\nTOP 100 4D TERKUAT:")
display(top100)

# 7) Simpan hasil ke CSV
output_file = "top100_prediksi_4d.csv"
top100.to_csv(output_file, index=False)
print("File tersimpan:", output_file)

try:
    files.download(output_file)
except Exception:
    pass

Model ini menggabungkan frekuensi kode, bobot data terbaru, pola digit per posisi, pola pasangan/triple digit, dan pola khusus slot 11:30.

Prediksi untuk hasil selanjutnya fokus TOP 100 4D ...

질문

Python

Python

Python

Python

Python

Python

사고

답변

TOP 100 4D terkuat

Script Google Colab

이 Q&A 공유하기