File size: 6,201 Bytes
e0bee9f | 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 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 | import os
import time
import gc
import sys
import numpy as np
try:
import psutil
HAS_PSUTIL = True
except ImportError:
HAS_PSUTIL = False
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import torch
from tqdm import tqdm
from joblib import Parallel, delayed
# SOTA-Tier Hardware Configuration Target N <= 2
N = 1
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)PATTERNS_PER_IMG = 10
RAM_LIMIT_GB = 11.5
os.makedirs(f'images_1C', exist_ok=True)
def draw_candle(ax, x, O, H, L, C):
color = 'green' if C > O else 'red' if C < O else 'black'
ax.plot([x, x], [L, H], color=color, linewidth=2)
top, bottom = max(O, C), min(O, C)
height = max(top - bottom, 0.2) if top == bottom else (top - bottom)
rect_y = bottom if top != bottom else bottom - 0.1
ax.add_patch(patches.Rectangle((x - 0.3, rect_y), 0.6, height, linewidth=1, edgecolor=color, facecolor=color))
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))
def render_batch_sota(batch_idx_start, batch_patterns, images_dir):
fig, axes = plt.subplots(2, 5, figsize=(20, 8))
fig.subplots_adjust(hspace=0.5, wspace=0.3)
ax_array = axes.flatten()
batch_results = []
img_name = f"plot_{batch_idx_start//PATTERNS_PER_IMG + 1}.png"
for ax in ax_array: ax.set_visible(False)
for j, p in enumerate(batch_patterns):
ax = ax_array[j]
ax.set_visible(True)
scale = 5.0
for k in range(N):
draw_candle(ax, k+1, p[k*4]*scale, p[k*4+1]*scale, p[k*4+2]*scale, p[k*4+3]*scale)
ax.set_ylim(-5, V*scale + 5)
ax.set_xlim(0, N+1)
ax.set_xticks([]); ax.set_yticks([])
pattern_id = f"P_{batch_idx_start+j:05d}"
logic_str = get_logic_string(p)
ax.set_title(f"{pattern_id}", fontsize=10)
ax.text(0.5, -0.1, logic_str, transform=ax.transAxes, fontsize=max(3, 10 - len(logic_str)//20), ha='center', va='top', wrap=True)
batch_results.append(f"| {pattern_id} | {logic_str} | {img_name} |")
img_path = os.path.join(images_dir, img_name)
fig.savefig(img_path, bbox_inches='tight')
plt.close(fig)
return batch_results
if __name__ == '__main__':
print(f"--- SOTA Visual Pattern Engine (EXHAUSTIVE EXACT): 1-candle ---")
start_time = time.time()
valid_single_candles = []
for h in range(V):
for l in range(h + 1):
for o in range(l, h + 1):
for c in range(l, h + 1):
valid_single_candles.append((o, h, l, c))
M = len(valid_single_candles)
total_permutations = M ** N
print(f"Combinations: {total_permutations:,} | Initializing VRAM/RAM Context...")
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
base_tensor = torch.tensor(valid_single_candles, dtype=torch.int16, device=device)
powers = (M ** torch.arange(N-1, -1, -1, device=device)).unsqueeze(0)
global_unique_chunks = []
limit_hit = False
try:
with tqdm(total=total_permutations, desc="Discovery Phase") as pbar:
for start_idx in range(0, total_permutations, BATCH_SIZE):
end_idx = min(start_idx + BATCH_SIZE, total_permutations)
curr_b = end_idx - start_idx
batch_idx = torch.arange(start_idx, end_idx, device=device).unsqueeze(1)
comb_idx = (batch_idx // powers) % M
candles = base_tensor[comb_idx].view(curr_b, 4 * N)
# Fast PyTorch Dense Ranking
sorted_c, indices = torch.sort(candles, dim=1)
diffs = torch.cat([torch.ones(curr_b, 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))
global_unique_chunks.append(torch.unique(ranks, dim=0).cpu())
if len(global_unique_chunks) > 10:
merged = torch.cat(global_unique_chunks, dim=0)
global_unique_chunks = [torch.unique(merged, dim=0)]
pbar.update(curr_b)
if HAS_PSUTIL and psutil.virtual_memory().used / (1024**3) > RAM_LIMIT_GB:
limit_hit = True; break
except Exception as e:
print(f"Error: {e}"); limit_hit = True
final_patterns_tensor = torch.unique(torch.cat(global_unique_chunks, dim=0), dim=0) if global_unique_chunks else torch.empty((0, 4*N))
patterns = final_patterns_tensor.tolist()
total_patterns = len(patterns)
print(f"Found {total_patterns} exact topological patterns in {time.time()-start_time:.2f}s.")
images_dir = f'images_1C'
render_tasks = [(i, patterns[i:i+PATTERNS_PER_IMG], images_dir) for i in range(0, total_patterns, PATTERNS_PER_IMG)]
md_rows = Parallel(n_jobs=-1, backend="loky")(
delayed(render_batch_sota)(*t) for t in tqdm(render_tasks, desc="SOTA Parallel Render")
)
markdown_lines = [
f"# Exhaustive Topological 1-Candle Patterns\n",
f"**Total unique combinations found:** {total_patterns}\n",
"| Pattern ID | Mathematical Logic | Image Reference |\n",
"|---|---|---|"
]
if limit_hit: markdown_lines.insert(2, "*OOM Limitation protection triggered!*\n")
for row_batch in md_rows: markdown_lines.extend(row_batch)
with open(f'1C_patterns.md', 'w') as f:
f.write("\n".join(markdown_lines))
print(f"SUCCESS! Total Time: {time.time() - start_time:.2f}s | Results in 1C_patterns.md")
|