bash -lc cat > /mnt/data/gru_colab_script.py <<'PY'

=============================================================

Prediksi hasil selanjutnya dengan GRU untuk Google Colab

File input: PRIZE_LEVEL_4_ELITE.csv

Catatan: model ini untuk eksperimen/pembelajaran. Hasil angka acak

seperti lottery/undian tidak dapat diprediksi dengan akurat secara konsisten.

=============================================================

import os, math, json, random import numpy as np import pandas as pd from sklearn.preprocessing import StandardScaler import torch from torch import nn from torch.utils.data import TensorDataset, DataLoader

---------- 1. Upload / set file CSV ----------

Jalankan cell ini di Google Colab. Jika file belum ada di runtime,

Colab akan meminta Anda upload PRIZE_LEVEL_4_ELITE.csv.

CSV_PATH = "PRIZE_LEVEL_4_ELITE.csv"

try: from google.colab import files if not os.path.exists(CSV_PATH): print("Upload file CSV Anda, contoh: PRIZE_LEVEL_4_ELITE.csv") uploaded = files.upload() CSV_PATH = list(uploaded.keys())[0] except Exception: # Bukan di Google Colab, gunakan path yang sudah ditentukan. pass

print("Menggunakan file:", CSV_PATH)

---------- 2. Konfigurasi ----------

SEED = 42 SEQ_LEN = 20 # jumlah baris historis untuk memprediksi baris berikutnya EPOCHS = 12 # naikkan misalnya 30-50 untuk eksperimen lebih lama BATCH_SIZE = 64 HIDDEN = 32 LR = 1e-3 PREDICT_ROWS = 3 # data historis punya 3 angka per timestamp, jadi prediksi 3 baris berikutnya

random.seed(SEED) np.random.seed(SEED) torch.manual_seed(SEED) torch.set_num_threads(1) try: torch.backends.mkldnn.enabled = False except Exception: pass

---------- 3. Load data ----------

df = pd.read_csv(CSV_PATH, dtype={"raw_number": str}) df["timestamp"] = pd.to_datetime(df["timestamp"]) df["_row_order"] = np.arange(len(df)) df = df.sort_values(["timestamp", "_row_order"]).reset_index(drop=True) df["raw_number"] = df["raw_number"].astype(str).str.zfill(4)

for c in ["d1", "d2", "d3", "d4"]: df[c] = df[c].astype(int)

feature_cols = [ "d1", "d2", "d3", "d4", "sum_digits", "p1", "p2", "p3", "p4", "m1", "m2", "m3", "m4", "is_double", "lag_1_sum", "lag_2_sum", "rolling_mean_sum_3", "h_sin", "h_cos" ] target_cols = ["d1", "d2", "d3", "d4"]

features = df[feature_cols].astype(float).values targets = df[target_cols].astype(int).values

print("Jumlah baris:", len(df)) print("Periode data:", df["timestamp"].min(), "sampai", df["timestamp"].max())

---------- 4. Buat sequence GRU ----------

Split kronologis agar validasi tetap realistis dan tidak bocor ke masa lalu.

n = len(df) cut = int(n * 0.8) scaler = StandardScaler().fit(features[:cut]) X_scaled = scaler.transform(features)

Xs, ys, target_indices = [], [], [] for i in range(SEQ_LEN, n): Xs.append(X_scaled[i-SEQ_LEN:i]) ys.append(targets[i]) target_indices.append(i)

X = np.array(Xs, dtype=np.float32) y = np.array(ys, dtype=np.int64) target_indices = np.array(target_indices)

train_mask = target_indices < cut val_mask = ~train_mask

X_train, y_train = X[train_mask], y[train_mask] X_val, y_val = X[val_mask], y[val_mask]

train_loader = DataLoader( TensorDataset(torch.tensor(X_train), torch.tensor(y_train)), batch_size=BATCH_SIZE, shuffle=True ) val_loader = DataLoader( TensorDataset(torch.tensor(X_val), torch.tensor(y_val)), batch_size=BATCH_SIZE, shuffle=False )

---------- 5. Model GRU multi-head ----------

class GRUDigitPredictor(nn.Module): def init(self, n_features, hidden=32): super().init() self.gru = nn.GRU( input_size=n_features, hidden_size=hidden, num_layers=1, batch_first=True ) self.dropout = nn.Dropout(0.2) self.heads = nn.ModuleList([nn.Linear(hidden, 10) for _ in range(4)])

text
def forward(self, x):
    out, _ = self.gru(x)
    z = self.dropout(out[:, -1, :])
    return [head(z) for head in self.heads]

model = GRUDigitPredictor(len(feature_cols), HIDDEN) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=LR)

---------- 6. Training & validasi ----------

def evaluate(loader): model.eval() total_loss, total = 0.0, 0 correct_digit, exact_4digit = 0, 0

text
with torch.no_grad():
    for xb, yb in loader:
        logits = model(xb)
        loss = sum(criterion(logits[j], yb[:, j]) for j in range(4))
        total_loss += loss.item() * len(xb)
        total += len(xb)

        pred = torch.stack([logits[j].argmax(dim=1) for j in range(4)], dim=1)
        correct_digit += (pred == yb).sum().item()
        exact_4digit += (pred == yb).all(dim=1).sum().item()

return total_loss / total, correct_digit / (total * 4), exact_4digit / total

best_state = None best_val_loss = float("inf") bad_epochs = 0 patience = 8

for epoch in range(1, EPOCHS + 1): model.train() train_loss_sum, train_count = 0.0, 0

text
for xb, yb in train_loader:
    optimizer.zero_grad()
    logits = model(xb)
    loss = sum(criterion(logits[j], yb[:, j]) for j in range(4))
    loss.backward()
    optimizer.step()
    train_loss_sum += loss.item() * len(xb)
    train_count += len(xb)

train_loss = train_loss_sum / train_count
val_loss, val_digit_acc, val_exact_acc = evaluate(val_loader)

print(
    f"Epoch {epoch:02d} | "
    f"train_loss={train_loss:.4f} | "
    f"val_loss={val_loss:.4f} | "
    f"digit_acc={val_digit_acc:.4f} | "
    f"exact_4digit_acc={val_exact_acc:.4f}"
)

if val_loss < best_val_loss:
    best_val_loss = val_loss
    best_state = {k: v.detach().clone() for k, v in model.state_dict().items()}
    bad_epochs = 0
else:
    bad_epochs += 1
    if bad_epochs >= patience:
        print("Early stopping.")
        break

if best_state is not None: model.load_state_dict(best_state)

val_loss, val_digit_acc, val_exact_acc = evaluate(val_loader) print("\nValidasi final:") print("val_loss:", round(val_loss, 4)) print("akurasi per digit:", round(val_digit_acc, 4)) print("akurasi tepat 4 digit:", round(val_exact_acc, 4))

---------- 7. Fungsi bantu prediksi ----------

def infer_next_timestamp(last_ts): # Slot yang terlihat dari data: 03:30, 06:30, 11:30, 13:30, 17:30, 21:30 slots = [(3, 30), (6, 30), (11, 30), (13, 30), (17, 30), (21, 30)] day0 = last_ts.normalize() for h, m in slots: candidate = day0 + pd.Timedelta(hours=h, minutes=m) if candidate > last_ts: return candidate h, m = slots[0] return day0 + pd.Timedelta(days=1, hours=h, minutes=m)

def make_feature_row(timestamp, digits, prev_sums): d1, d2, d3, d4 = [int(x) for x in digits] s = d1 + d2 + d3 + d4 hour = timestamp.hour + timestamp.minute / 60 angle = 2 * math.pi * hour / 24

text
return {
    "timestamp": timestamp,
    "raw_number": f"{d1}{d2}{d3}{d4}",
    "d1": d1, "d2": d2, "d3": d3, "d4": d4,
    "sum_digits": s,
    "p1": d1 % 2, "p2": d2 % 2, "p3": d3 % 2, "p4": d4 % 2,
    "m1": 1 if d1 >= 5 else 0,
    "m2": 1 if d2 >= 5 else 0,
    "m3": 1 if d3 >= 5 else 0,
    "m4": 1 if d4 >= 5 else 0,
    "is_double": 1 if len({d1, d2, d3, d4}) < 4 else 0,
    "lag_1_sum": prev_sums[-1] if len(prev_sums) >= 1 else 0,
    "lag_2_sum": prev_sums[-2] if len(prev_sums) >= 2 else 0,
    "rolling_mean_sum_3": float(np.mean(prev_sums[-3:])) if len(prev_sums) >= 3 else 0,
    "h_sin": math.sin(angle),
    "h_cos": math.cos(angle),
}

def top_combinations_from_probs(probs, top_k_each_digit=3, top_n=10): top_per_digit = [] for p in probs: idx = np.argsort(-p)[:top_k_each_digit] top_per_digit.append([(int(i), float(p[i])) for i in idx])

text
combos = []
for a, pa in top_per_digit[0]:
    for b, pb in top_per_digit[1]:
        for c, pc in top_per_digit[2]:
            for d, pd_ in top_per_digit[3]:
                combos.append((f"{a}{b}{c}{d}", pa * pb * pc * pd_))

return sorted(combos, key=lambda x: x[1], reverse=True)[:top_n]

---------- 8. Prediksi hasil selanjutnya ----------

last_ts = df["timestamp"].iloc[-1] next_ts = infer_next_timestamp(last_ts) work_df = df.copy() future_rows = [] detail_predictions = []

for step in range(PREDICT_ROWS): window = work_df[feature_cols].astype(float).values[-SEQ_LEN:] x_next = torch.tensor(scaler.transform(window)[None, :, :], dtype=torch.float32)

text
model.eval()
with torch.no_grad():
    logits = model(x_next)
    probs = [torch.softmax(logit, dim=1).cpu().numpy()[0] for logit in logits]

pred_digits = [int(np.argmax(p)) for p in probs]
pred_row = make_feature_row(next_ts, pred_digits, list(work_df["sum_digits"].astype(float).values))
future_rows.append(pred_row)

top10 = top_combinations_from_probs(probs, top_k_each_digit=3, top_n=10)
detail_predictions.append({
    "urutan": step + 1,
    "timestamp_prediksi": str(next_ts),
    "prediksi_utama": pred_row["raw_number"],
    "top10_kandidat": top10,
    "top5_per_digit": [
        [(int(i), float(p[i])) for i in np.argsort(-p)[:5]]
        for p in probs
    ]
})

work_df = pd.concat([work_df, pd.DataFrame([pred_row])], ignore_index=True)

pred_df = pd.DataFrame(future_rows) print("\nPrediksi utama untuk timestamp berikutnya:") print(pred_df[["timestamp", "raw_number", "sum_digits", "is_double"]])

print("\nDetail kandidat:") for item in detail_predictions: print("\nUrutan", item["urutan"], "prediksi utama:", item["prediksi_utama"]) print("Top 10 kandidat:") for nomor, skor in item["top10_kandidat"]: print(f" {nomor} skor={skor:.8f}")

---------- 9. Simpan hasil ----------

pred_df.to_csv("gru_prediction_results.csv", index=False) with open("gru_prediction_details.json", "w") as f: json.dump(detail_predictions, f, indent=2)

print("\nFile tersimpan:") print("- gru_prediction_results.csv") print("- gru_prediction_details.json")

try: from google.colab import files files.download("gru_prediction_results.csv") files.download("gru_prediction_details.json") except Exception: pass PY python - <<'PY' import json, textwrap, pathlib script = pathlib.Path('/mnt/data/gru_colab_script.py').read_text()

Split into notebook cells for usability

cells=[] intro = """# Prediksi Hasil Selanjutnya dengan GRU\n\nNotebook ini membaca PRIZE_LEVEL_4_ELITE.csv, melatih model GRU multi-output untuk 4 digit, lalu memprediksi 3 baris berikutnya untuk timestamp berikutnya.\n\nCatatan penting: bila data ini adalah hasil undian/lottery, angka bersifat acak. Model ini untuk eksperimen dan tidak menjamin prediksi benar.""" cells.append({"cell_type":"markdown","metadata":{},"source":[line+'\n' for line in intro.split('\n')]})

Put full script in one code cell to make it easy to run all

cells.append({"cell_type":"code","execution_count":None,"metadata":{},"outputs":[],"source":[line+'\n' for line in script.split('\n')]}) nb={"cells":cells,"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},"nbformat":4,"nbformat_minor":5} path='/mnt/data/GRU_Prediksi_Hasil_Selanjutnya.ipynb' with open(path,'w') as f: json.dump(nb,f,indent=2) print(path) PY ls -l /mnt/data/gru_colab_script.py /mnt/data/GRU_Prediksi_Hasil_Selanjutnya.ipynb /mnt/data/gru_prediction_results.csv /mnt/data/gru_prediction_summary.json

Thought for 6m 15s