Upload 2 files

1C_patterns_fast.md

@@ -0,0 +1,18 @@
+# Exhaustive Topological 1-Candle Patterns
+
+**Total Patterns:** 12
+
+| Pattern ID | Mathematical Logic |
+|---|---|
+| P_00000 | (O1 = H1 = L1 = C1) |
+| P_00001 | (H1) > (O1 = L1 = C1) |
+| P_00002 | (H1 = C1) > (O1 = L1) |
+| P_00003 | (H1) > (C1) > (O1 = L1) |
+| P_00004 | (O1 = H1) > (L1 = C1) |
+| P_00005 | (O1 = H1 = C1) > (L1) |
+| P_00006 | (H1) > (O1) > (L1 = C1) |
+| P_00007 | (H1) > (O1 = C1) > (L1) |
+| P_00008 | (H1 = C1) > (O1) > (L1) |
+| P_00009 | (H1) > (C1) > (O1) > (L1) |
+| P_00010 | (O1 = H1) > (C1) > (L1) |
+| P_00011 | (H1) > (O1) > (C1) > (L1) |

1_candle_pattern.py

@@ -0,0 +1,147 @@
+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")