File size: 4,246 Bytes
d48606c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 | import os
import time
import gc
import sys
try:
import psutil
HAS_PSUTIL = True
except ImportError:
HAS_PSUTIL = False
import torch
from tqdm import tqdm
# SOTA-Tier Hardware Configuration Target N > 2 (Stochastic GPU Sampling)
N = 4
V = 4 * N
BATCH_SIZE = max(10_000, 2_000_000 // N) if not torch.cuda.is_available() else max(20_000, 5_000_000 // N)
RAM_LIMIT_GB = 11.5
MAX_TIME_SEC = 4.85 * 3600 # Almost 5 hours minus 10 mins
def get_logic_string(p):
labels = []
for i in range(1, N+1): labels.extend([f'O{i}', f'H{i}', f'L{i}', f'C{i}'])
groups = {}
for i, val in enumerate(p):
groups.setdefault(val, []).append(labels[i])
return " > ".join("(" + " = ".join(groups[val]) + ")" for val in sorted(groups.keys(), reverse=True))
if __name__ == '__main__':
print(f"--- SOTA Fast Topological Engine (STOCHASTIC DISCOVERY): 4-candle ---")
start_time = time.time()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Device: {device} | Fast Topology Batches: {BATCH_SIZE:,}")
unique_patterns = set()
limit_hit = False
try:
with tqdm(desc="Stochastic Discovery Phase") as pbar:
while time.time() - start_time < MAX_TIME_SEC:
# Stochastic Generative Constructive Mathematics
O = torch.randint(0, V, (BATCH_SIZE, N), device=device, dtype=torch.int16)
C = torch.randint(0, V, (BATCH_SIZE, N), device=device, dtype=torch.int16)
top = torch.maximum(O, C)
bot = torch.minimum(O, C)
R = torch.rand((BATCH_SIZE, N), device=device)
H_diff = (V - top)
H = top + (R * H_diff).to(torch.int16)
R2 = torch.rand((BATCH_SIZE, N), device=device)
L = (R2 * (bot + 1)).to(torch.int16)
candles = torch.stack([O, H, L, C], dim=-1).view(BATCH_SIZE, 4 * N)
# GPU Dense Ranking Fubini mapping
sorted_c, indices = torch.sort(candles, dim=1)
diffs = torch.cat([torch.ones(BATCH_SIZE, 1, device=device, dtype=torch.int16), (sorted_c[:, 1:] > sorted_c[:, :-1]).to(torch.int16)], dim=1)
cum_ranks = torch.cumsum(diffs, dim=1) - 1
ranks = torch.empty_like(candles)
ranks.scatter_(1, indices, cum_ranks.to(torch.int16))
# Deduplication
b_unique = torch.unique(ranks, dim=0).cpu().numpy()
before_len = len(unique_patterns)
for row in b_unique:
unique_patterns.add(tuple(row))
added = len(unique_patterns) - before_len
pbar.update(added)
pbar.set_postfix(unique=len(unique_patterns))
if HAS_PSUTIL and psutil.virtual_memory().used / (1024**3) > RAM_LIMIT_GB:
print("\nMemory limit reached. Transitioning to export.")
limit_hit = True
break
except KeyboardInterrupt:
print("\nInterrupted. Moving to export.")
except Exception as e:
print(f"\nError: {e}"); limit_hit = True
patterns = sorted(list(unique_patterns))
total_patterns = len(patterns)
elapsed = time.time() - start_time
print(f"Discovered {total_patterns} exact patterns in {elapsed:.2f}s.")
md_path = f'4C_patterns_fast.md'
with open(md_path, 'w') as f:
f.write(f"# Extracted Topological 4-Candle Patterns (Stochastic)\n\n")
f.write(f"**Patterns Discovered in 5hrs:** {total_patterns}\n\n")
if limit_hit: f.write("*Memory limit triggered seamlessly.*\n\n")
f.write(f"| Pattern ID | Mathematical Logic |\n|---|---|\n")
# Write streaming to save memory in memory-constrained environment
for i, p in enumerate(patterns):
f.write(f"| P_{i:05d} | {get_logic_string(p)} |\n")
print(f"SUCCESS! Total Time: {time.time() - start_time:.2f}s | Saved to {md_path}")
|