| <!DOCTYPE html> |
| <html lang="en"> |
| <head> |
| <meta charset="UTF-8"> |
| <meta name="viewport" content="width=device-width, initial-scale=1.0"> |
| <title>ANN CHESS RL TRAINER v3.0</title> |
| |
| |
| <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@4.10.0/dist/tf.min.js"></script> |
| |
| |
| <script src="https://cdnjs.cloudflare.com/ajax/libs/chess.js/0.12.0/chess.min.js"></script> |
| |
| |
| <script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script> |
| |
| |
| <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css"> |
| |
| <style> |
| :root { |
| --neon-green: #39FF14; |
| --neon-blue: #00F3FF; |
| --neon-purple: #aa00ff; |
| --neon-red: #ff073a; |
| --neon-yellow: #ffd300; |
| --dark-bg: #0a0a0a; |
| --panel-bg: rgba(15, 15, 15, 0.95); |
| --grid-bg: rgba(0, 20, 0, 0.3); |
| } |
| |
| * { |
| margin: 0; |
| padding: 0; |
| box-sizing: border-box; |
| font-family: 'Courier New', monospace; |
| } |
| |
| body { |
| background: var(--dark-bg); |
| color: var(--neon-green); |
| overflow: hidden; |
| height: 100vh; |
| position: relative; |
| } |
| |
| |
| #quantum-field { |
| position: fixed; |
| top: 0; |
| left: 0; |
| width: 100%; |
| height: 100%; |
| pointer-events: none; |
| z-index: -1; |
| opacity: 0.3; |
| } |
| |
| |
| #loading-screen { |
| position: fixed; |
| top: 0; |
| left: 0; |
| width: 100%; |
| height: 100%; |
| background: var(--dark-bg); |
| display: flex; |
| flex-direction: column; |
| justify-content: center; |
| align-items: center; |
| z-index: 9999; |
| } |
| |
| .glitch-text { |
| font-size: 3rem; |
| font-weight: bold; |
| text-transform: uppercase; |
| position: relative; |
| color: var(--neon-green); |
| text-shadow: 0.05em 0 0 var(--neon-green), -0.05em -0.025em 0 var(--neon-purple); |
| animation: glitch 1s infinite; |
| } |
| |
| @keyframes glitch { |
| 0% { transform: translate(0); } |
| 20% { transform: translate(-2px, 2px); } |
| 40% { transform: translate(-2px, -2px); } |
| 60% { transform: translate(2px, 2px); } |
| 80% { transform: translate(2px, -2px); } |
| 100% { transform: translate(0); } |
| } |
| |
| .loading-subtitle { |
| font-size: 1.2rem; |
| margin: 2rem 0; |
| color: var(--neon-blue); |
| } |
| |
| .loading-progress { |
| width: 400px; |
| height: 8px; |
| background: rgba(57, 255, 20, 0.2); |
| border-radius: 4px; |
| overflow: hidden; |
| } |
| |
| .loading-bar { |
| height: 100%; |
| background: linear-gradient(90deg, var(--neon-green), var(--neon-blue)); |
| width: 0%; |
| transition: width 0.5s; |
| box-shadow: 0 0 10px var(--neon-green); |
| } |
| |
| |
| .container { |
| display: flex; |
| height: 100vh; |
| padding: 10px; |
| gap: 10px; |
| opacity: 0; |
| transition: opacity 1s; |
| } |
| |
| |
| .panel { |
| flex: 1; |
| background: var(--panel-bg); |
| border: 1px solid var(--neon-green); |
| border-radius: 8px; |
| padding: 15px; |
| display: flex; |
| flex-direction: column; |
| min-width: 320px; |
| box-shadow: 0 0 20px rgba(0, 255, 0, 0.1); |
| } |
| |
| .black-panel { |
| border-color: #fff; |
| } |
| |
| .green-panel { |
| border-color: var(--neon-green); |
| } |
| |
| .panel-title { |
| text-align: center; |
| font-size: 1.2rem; |
| margin-bottom: 15px; |
| color: var(--neon-green); |
| text-shadow: 0 0 10px currentColor; |
| padding-bottom: 8px; |
| border-bottom: 2px solid currentColor; |
| } |
| |
| .black-panel .panel-title { |
| color: #fff; |
| } |
| |
| .green-panel .panel-title { |
| color: var(--neon-green); |
| } |
| |
| |
| .metric-grid { |
| display: grid; |
| grid-template-columns: repeat(2, 1fr); |
| gap: 10px; |
| margin-bottom: 15px; |
| } |
| |
| .metric-card { |
| background: rgba(0, 30, 0, 0.3); |
| border: 1px solid rgba(0, 255, 0, 0.2); |
| border-radius: 6px; |
| padding: 10px; |
| transition: all 0.3s; |
| } |
| |
| .black-panel .metric-card { |
| border-color: rgba(255, 255, 255, 0.2); |
| } |
| |
| .metric-card:hover { |
| border-color: currentColor; |
| box-shadow: 0 0 15px rgba(0, 255, 0, 0.3); |
| } |
| |
| .metric-label { |
| font-size: 0.8rem; |
| color: #aaa; |
| margin-bottom: 5px; |
| } |
| |
| .metric-value { |
| font-size: 1.2rem; |
| font-weight: bold; |
| color: var(--neon-green); |
| } |
| |
| .black-panel .metric-value { |
| color: #fff; |
| } |
| |
| .metric-unit { |
| font-size: 0.8rem; |
| color: var(--neon-blue); |
| } |
| |
| |
| .training-controller { |
| background: rgba(0, 20, 0, 0.3); |
| padding: 15px; |
| border-radius: 8px; |
| border: 1px solid rgba(0, 255, 0, 0.2); |
| margin-bottom: 15px; |
| } |
| |
| .controller-title { |
| font-size: 0.9rem; |
| color: var(--neon-blue); |
| margin-bottom: 10px; |
| text-align: center; |
| } |
| |
| .slider-group { |
| margin-bottom: 12px; |
| } |
| |
| .slider-label { |
| display: block; |
| margin-bottom: 5px; |
| color: var(--neon-blue); |
| font-size: 0.85rem; |
| } |
| |
| .black-panel .slider-label { |
| color: #aaa; |
| } |
| |
| .slider-container { |
| display: flex; |
| align-items: center; |
| gap: 10px; |
| } |
| |
| input[type="range"] { |
| flex: 1; |
| height: 6px; |
| background: rgba(0, 255, 0, 0.1); |
| border-radius: 3px; |
| outline: none; |
| } |
| |
| .black-panel input[type="range"] { |
| background: rgba(255, 255, 255, 0.1); |
| } |
| |
| input[type="range"]::-webkit-slider-thumb { |
| appearance: none; |
| width: 16px; |
| height: 16px; |
| border-radius: 50%; |
| background: var(--neon-green); |
| cursor: pointer; |
| box-shadow: 0 0 8px var(--neon-green); |
| } |
| |
| .black-panel input[type="range"]::-webkit-slider-thumb { |
| background: #fff; |
| box-shadow: 0 0 8px #fff; |
| } |
| |
| .slider-value { |
| min-width: 60px; |
| text-align: right; |
| color: var(--neon-green); |
| font-weight: bold; |
| font-size: 0.9rem; |
| } |
| |
| .black-panel .slider-value { |
| color: #fff; |
| } |
| |
| |
| .nn-visualization { |
| height: 180px; |
| background: rgba(0, 0, 0, 0.5); |
| border: 1px solid var(--neon-green); |
| border-radius: 6px; |
| padding: 10px; |
| position: relative; |
| overflow: hidden; |
| margin-bottom: 15px; |
| } |
| |
| .black-panel .nn-visualization { |
| border-color: #fff; |
| } |
| |
| .nn-layer { |
| position: absolute; |
| top: 10px; |
| bottom: 10px; |
| display: flex; |
| flex-direction: column; |
| justify-content: space-around; |
| } |
| |
| .neuron { |
| width: 10px; |
| height: 10px; |
| border-radius: 50%; |
| background: var(--neon-green); |
| margin: 5px auto; |
| opacity: 0.8; |
| transition: all 0.3s; |
| box-shadow: 0 0 5px currentColor; |
| } |
| |
| .black-panel .neuron { |
| background: #fff; |
| box-shadow: 0 0 5px #fff; |
| } |
| |
| .neuron.active { |
| opacity: 1; |
| background: var(--neon-red); |
| box-shadow: 0 0 12px var(--neon-red); |
| animation: pulse 0.8s infinite; |
| } |
| |
| .black-panel .neuron.active { |
| background: var(--neon-red); |
| box-shadow: 0 0 12px var(--neon-red); |
| } |
| |
| @keyframes pulse { |
| 0%, 100% { transform: scale(1); } |
| 50% { transform: scale(1.3); } |
| } |
| |
| .connection { |
| position: absolute; |
| background: rgba(0, 255, 0, 0.2); |
| transform-origin: 0 0; |
| } |
| |
| .black-panel .connection { |
| background: rgba(255, 255, 255, 0.2); |
| } |
| |
| |
| .agent-log { |
| background: rgba(0, 20, 0, 0.8); |
| border: 1px solid var(--neon-green); |
| border-radius: 6px; |
| padding: 10px; |
| font-family: 'Courier New', monospace; |
| font-size: 11px; |
| flex: 1; |
| min-height: 150px; |
| overflow-y: auto; |
| margin-top: auto; |
| } |
| |
| .black-panel .agent-log { |
| border-color: #fff; |
| background: rgba(20, 20, 20, 0.8); |
| } |
| |
| .log-header { |
| display: flex; |
| justify-content: space-between; |
| margin-bottom: 8px; |
| color: var(--neon-green); |
| font-weight: bold; |
| font-size: 0.9rem; |
| padding-bottom: 5px; |
| border-bottom: 1px solid rgba(0, 255, 0, 0.3); |
| } |
| |
| .black-panel .log-header { |
| color: #fff; |
| border-bottom: 1px solid rgba(255, 255, 255, 0.3); |
| } |
| |
| .log-line { |
| margin: 3px 0; |
| line-height: 1.3; |
| word-wrap: break-word; |
| } |
| |
| .log-line.info { color: var(--neon-blue); } |
| .log-line.success { color: var(--neon-green); } |
| .log-line.warning { color: var(--neon-yellow); } |
| .log-line.error { color: var(--neon-red); } |
| |
| .black-panel .log-line.info { color: #aaa; } |
| .black-panel .log-line.success { color: #fff; } |
| .black-panel .log-line.warning { color: #ffaa00; } |
| .black-panel .log-line.error { color: #ff5555; } |
| |
| |
| .center-arena { |
| flex: 2; |
| display: flex; |
| flex-direction: column; |
| gap: 10px; |
| min-width: 500px; |
| } |
| |
| |
| .chess-arena { |
| background: var(--panel-bg); |
| border: 2px solid var(--neon-green); |
| border-radius: 8px; |
| padding: 20px; |
| display: flex; |
| flex-direction: column; |
| align-items: center; |
| box-shadow: 0 0 30px rgba(0, 255, 0, 0.2); |
| } |
| |
| .arena-header { |
| width: 100%; |
| display: flex; |
| justify-content: space-between; |
| margin-bottom: 15px; |
| color: var(--neon-green); |
| font-size: 1.1rem; |
| } |
| |
| .chess-board-container { |
| display: flex; |
| flex-direction: column; |
| align-items: center; |
| } |
| |
| .chess-board { |
| display: grid; |
| grid-template-columns: repeat(8, 1fr); |
| grid-template-rows: repeat(8, 1fr); |
| width: 400px; |
| height: 400px; |
| border: 3px solid var(--neon-green); |
| box-shadow: 0 0 25px rgba(0, 255, 0, 0.4); |
| } |
| |
| .chess-square { |
| display: flex; |
| align-items: center; |
| justify-content: center; |
| font-size: 28px; |
| position: relative; |
| cursor: default; |
| } |
| |
| .chess-square.light { |
| background: rgba(30, 40, 30, 0.8); |
| } |
| |
| .chess-square.dark { |
| background: rgba(10, 20, 10, 0.8); |
| } |
| |
| .chess-square.highlight { |
| background: rgba(0, 255, 0, 0.3); |
| box-shadow: inset 0 0 10px rgba(0, 255, 0, 0.5); |
| } |
| |
| |
| .controls { |
| display: grid; |
| grid-template-columns: repeat(5, 1fr); |
| gap: 10px; |
| padding: 15px; |
| background: var(--panel-bg); |
| border: 1px solid var(--neon-green); |
| border-radius: 8px; |
| } |
| |
| .btn { |
| padding: 10px; |
| border-radius: 6px; |
| border: none; |
| font-weight: bold; |
| cursor: pointer; |
| transition: all 0.3s; |
| font-size: 0.9rem; |
| text-transform: uppercase; |
| letter-spacing: 1px; |
| } |
| |
| .btn-primary { |
| background: rgba(0, 255, 0, 0.1); |
| color: var(--neon-green); |
| border: 2px solid var(--neon-green); |
| } |
| |
| .btn-primary:hover { |
| background: rgba(0, 255, 0, 0.3); |
| box-shadow: 0 0 20px var(--neon-green); |
| transform: translateY(-2px); |
| } |
| |
| .btn-blue { |
| background: rgba(0, 243, 255, 0.1); |
| color: var(--neon-blue); |
| border: 2px solid var(--neon-blue); |
| } |
| |
| .btn-blue:hover { |
| background: rgba(0, 243, 255, 0.3); |
| box-shadow: 0 0 20px var(--neon-blue); |
| } |
| |
| .btn-red { |
| background: rgba(255, 7, 58, 0.1); |
| color: var(--neon-red); |
| border: 2px solid var(--neon-red); |
| } |
| |
| .btn-red:hover { |
| background: rgba(255, 7, 58, 0.3); |
| box-shadow: 0 0 20px var(--neon-red); |
| } |
| |
| .btn-purple { |
| background: rgba(170, 0, 255, 0.1); |
| color: var(--neon-purple); |
| border: 2px solid var(--neon-purple); |
| } |
| |
| .btn-purple:hover { |
| background: rgba(170, 0, 255, 0.3); |
| box-shadow: 0 0 20px var(--neon-purple); |
| } |
| |
| |
| .progress-section { |
| display: flex; |
| gap: 10px; |
| align-items: center; |
| padding: 15px; |
| background: var(--panel-bg); |
| border: 1px solid var(--neon-green); |
| border-radius: 8px; |
| } |
| |
| .progress-container { |
| flex: 1; |
| height: 8px; |
| background: rgba(0, 255, 0, 0.1); |
| border-radius: 4px; |
| overflow: hidden; |
| } |
| |
| .progress-bar { |
| height: 100%; |
| background: linear-gradient(90deg, var(--neon-green), var(--neon-blue)); |
| width: 0%; |
| transition: width 0.5s; |
| box-shadow: 0 0 10px currentColor; |
| } |
| |
| |
| .main-terminal { |
| flex: 1; |
| background: rgba(0, 20, 0, 0.8); |
| border: 1px solid var(--neon-green); |
| border-radius: 8px; |
| padding: 15px; |
| font-family: 'Courier New', monospace; |
| font-size: 12px; |
| display: flex; |
| flex-direction: column; |
| } |
| |
| .terminal-header { |
| display: flex; |
| justify-content: space-between; |
| margin-bottom: 10px; |
| color: var(--neon-green); |
| font-weight: bold; |
| padding-bottom: 8px; |
| border-bottom: 1px solid rgba(0, 255, 0, 0.3); |
| } |
| |
| .terminal-content { |
| flex: 1; |
| overflow-y: auto; |
| } |
| |
| .terminal-line { |
| margin: 4px 0; |
| line-height: 1.4; |
| word-wrap: break-word; |
| } |
| |
| .terminal-line.info { color: var(--neon-blue); } |
| .terminal-line.success { color: var(--neon-green); } |
| .terminal-line.warning { color: var(--neon-yellow); } |
| .terminal-line.error { color: var(--neon-red); } |
| |
| |
| @media (max-width: 1200px) { |
| .container { |
| flex-direction: column; |
| } |
| .panel, .center-arena { |
| min-width: unset; |
| } |
| .chess-board { |
| width: 300px; |
| height: 300px; |
| } |
| .controls { |
| grid-template-columns: repeat(3, 1fr); |
| } |
| } |
| |
| @media (max-width: 768px) { |
| .chess-board { |
| width: 250px; |
| height: 250px; |
| } |
| .controls { |
| grid-template-columns: repeat(2, 1fr); |
| } |
| .metric-grid { |
| grid-template-columns: 1fr; |
| } |
| } |
| </style> |
| </head> |
| <body> |
| |
| <div id="loading-screen"> |
| <div class="glitch-text">ANN CHESS RL TRAINER v3.0</div> |
| <div class="loading-subtitle">Initializing Neural Networks & Training Environment...</div> |
| <div class="loading-progress"> |
| <div class="loading-bar"></div> |
| </div> |
| <div id="loading-details" style="margin-top: 20px; color: var(--neon-blue); font-size: 0.9rem;"></div> |
| </div> |
|
|
| |
| <canvas id="quantum-field"></canvas> |
|
|
| |
| <div class="container"> |
| |
| <div class="panel black-panel"> |
| <div class="panel-title">BLACK AGENT (Policy Network)</div> |
| |
| <div class="metric-grid"> |
| <div class="metric-card"> |
| <div class="metric-label">Win Rate</div> |
| <div class="metric-value" id="black-win-rate">0.0<span class="metric-unit">%</span></div> |
| </div> |
| <div class="metric-card"> |
| <div class="metric-label">Loss Value</div> |
| <div class="metric-value" id="black-loss">0.000</div> |
| </div> |
| <div class="metric-card"> |
| <div class="metric-label">Learning Rate</div> |
| <div class="metric-value" id="black-lr">0.0010</div> |
| </div> |
| <div class="metric-card"> |
| <div class="metric-label">Exploration</div> |
| <div class="metric-value" id="black-explore">0.30</div> |
| </div> |
| <div class="metric-card"> |
| <div class="metric-label">Games Played</div> |
| <div class="metric-value" id="black-games">0</div> |
| </div> |
| <div class="metric-card"> |
| <div class="metric-label">Moves Made</div> |
| <div class="metric-value" id="black-moves">0</div> |
| </div> |
| </div> |
|
|
| <div class="training-controller"> |
| <div class="controller-title">NEURAL NETWORK CONTROLS</div> |
| <div class="slider-group"> |
| <label class="slider-label">Learning Rate</label> |
| <div class="slider-container"> |
| <input type="range" min="1" max="100" value="10" |
| oninput="updateAgentParam('black', 'learningRate', this.value/10000)"> |
| <span class="slider-value" id="black-lr-value">0.0010</span> |
| </div> |
| </div> |
| <div class="slider-group"> |
| <label class="slider-label">Exploration Rate</label> |
| <div class="slider-container"> |
| <input type="range" min="0" max="100" value="30" |
| oninput="updateAgentParam('black', 'explorationRate', this.value/100)"> |
| <span class="slider-value" id="black-explore-value">0.30</span> |
| </div> |
| </div> |
| <div class="slider-group"> |
| <label class="slider-label">Discount Factor</label> |
| <div class="slider-container"> |
| <input type="range" min="50" max="99" value="95" |
| oninput="updateAgentParam('black', 'discountFactor', this.value/100)"> |
| <span class="slider-value" id="black-discount-value">0.95</span> |
| </div> |
| </div> |
| </div> |
|
|
| <div class="nn-visualization" id="black-nn-viz"> |
| |
| </div> |
|
|
| <div class="agent-log"> |
| <div class="log-header"> |
| <span>Black Agent Log</span> |
| <span id="black-log-count">0</span> |
| </div> |
| <div id="black-log-content"></div> |
| </div> |
| </div> |
|
|
| |
| <div class="center-arena"> |
| <div class="chess-arena"> |
| <div class="arena-header"> |
| <span>BLACK</span> |
| <span id="current-turn">White to move</span> |
| <span>GREEN</span> |
| </div> |
| <div class="chess-board-container"> |
| <div class="chess-board" id="chess-board"> |
| |
| </div> |
| <div style="margin-top: 15px; color: var(--neon-blue); font-size: 0.9rem;"> |
| Game #<span id="current-game">1</span> | Moves: <span id="current-moves">0</span> |
| </div> |
| </div> |
| </div> |
|
|
| <div class="controls"> |
| <button class="btn btn-primary" onclick="startTraining()" id="start-btn"> |
| <i class="fas fa-play"></i> Start Training |
| </button> |
| <button class="btn btn-red" onclick="pauseTraining()" id="pause-btn" style="display: none;"> |
| <i class="fas fa-pause"></i> Pause Training |
| </button> |
| <button class="btn btn-blue" onclick="exportEverything()" id="export-btn"> |
| <i class="fas fa-file-export"></i> Export All |
| </button> |
| <button class="btn btn-purple" onclick="resetTraining()"> |
| <i class="fas fa-redo"></i> Reset All |
| </button> |
| <button class="btn btn-primary" onclick="saveState()"> |
| <i class="fas fa-save"></i> Save State |
| </button> |
| </div> |
|
|
| <div class="progress-section"> |
| <div class="progress-container"> |
| <div class="progress-bar" id="training-progress"></div> |
| </div> |
| <span style="color: var(--neon-green); font-weight: bold; min-width: 200px;"> |
| Games: <span id="total-games">0</span> | Moves: <span id="total-moves">0</span> |
| </span> |
| </div> |
|
|
| <div class="main-terminal"> |
| <div class="terminal-header"> |
| <span>TRAINING CONSOLE</span> |
| <span id="training-timer">00:00:00</span> |
| </div> |
| <div class="terminal-content" id="main-terminal"></div> |
| </div> |
| </div> |
|
|
| |
| <div class="panel green-panel"> |
| <div class="panel-title">GREEN AGENT (Value Network)</div> |
| |
| <div class="metric-grid"> |
| <div class="metric-card"> |
| <div class="metric-label">Win Rate</div> |
| <div class="metric-value" id="green-win-rate">0.0<span class="metric-unit">%</span></div> |
| </div> |
| <div class="metric-card"> |
| <div class="metric-label">Loss Value</div> |
| <div class="metric-value" id="green-loss">0.000</div> |
| </div> |
| <div class="metric-card"> |
| <div class="metric-label">Learning Rate</div> |
| <div class="metric-value" id="green-lr">0.0010</div> |
| </div> |
| <div class="metric-card"> |
| <div class="metric-label">Exploration</div> |
| <div class="metric-value" id="green-explore">0.30</div> |
| </div> |
| <div class="metric-card"> |
| <div class="metric-label">Games Played</div> |
| <div class="metric-value" id="green-games">0</div> |
| </div> |
| <div class="metric-card"> |
| <div class="metric-label">Moves Made</div> |
| <div class="metric-value" id="green-moves">0</div> |
| </div> |
| </div> |
|
|
| <div class="training-controller"> |
| <div class="controller-title">NEURAL NETWORK CONTROLS</div> |
| <div class="slider-group"> |
| <label class="slider-label">Learning Rate</label> |
| <div class="slider-container"> |
| <input type="range" min="1" max="100" value="10" |
| oninput="updateAgentParam('green', 'learningRate', this.value/10000)"> |
| <span class="slider-value" id="green-lr-value">0.0010</span> |
| </div> |
| </div> |
| <div class="slider-group"> |
| <label class="slider-label">Exploration Rate</label> |
| <div class="slider-container"> |
| <input type="range" min="0" max="100" value="30" |
| oninput="updateAgentParam('green', 'explorationRate', this.value/100)"> |
| <span class="slider-value" id="green-explore-value">0.30</span> |
| </div> |
| </div> |
| <div class="slider-group"> |
| <label class="slider-label">Discount Factor</label> |
| <div class="slider-container"> |
| <input type="range" min="50" max="99" value="95" |
| oninput="updateAgentParam('green', 'discountFactor', this.value/100)"> |
| <span class="slider-value" id="green-discount-value">0.95</span> |
| </div> |
| </div> |
| </div> |
|
|
| <div class="nn-visualization" id="green-nn-viz"> |
| |
| </div> |
|
|
| <div class="agent-log"> |
| <div class="log-header"> |
| <span>Green Agent Log</span> |
| <span id="green-log-count">0</span> |
| </div> |
| <div id="green-log-content"></div> |
| </div> |
| </div> |
| </div> |
|
|
| <script> |
| |
| const state = { |
| trainingActive: false, |
| game: null, |
| currentGameNumber: 1, |
| trainingStartTime: null, |
| trainingTimer: null, |
| lastAutoSave: null, |
| realTimeInterval: null, |
| |
| |
| neuralNetworks: { |
| black: null, |
| green: null |
| }, |
| |
| |
| agents: { |
| black: null, |
| green: null |
| }, |
| |
| |
| agentStats: { |
| black: { |
| wins: 0, |
| losses: 0, |
| draws: 0, |
| totalGames: 0, |
| movesMade: 0, |
| learningRate: 0.001, |
| explorationRate: 0.3, |
| discountFactor: 0.95, |
| lossHistory: [] |
| }, |
| green: { |
| wins: 0, |
| losses: 0, |
| draws: 0, |
| totalGames: 0, |
| movesMade: 0, |
| learningRate: 0.001, |
| explorationRate: 0.3, |
| discountFactor: 0.95, |
| lossHistory: [] |
| } |
| }, |
| |
| |
| dataset: [], |
| validGames: 0, |
| totalMoves: 0, |
| currentGameData: null |
| }; |
| |
| |
| function calculateMaterialAdvantage(game) { |
| const pieceValues = { p: 1, n: 3, b: 3, r: 5, q: 9, k: 0 }; |
| let white = 0, black = 0; |
| |
| game.board().forEach(row => { |
| row.forEach(piece => { |
| if (piece) { |
| const value = pieceValues[piece.type] || 0; |
| if (piece.color === 'w') white += value; |
| else black += value; |
| } |
| }); |
| }); |
| |
| return white - black; |
| } |
| |
| function calculateCenterControl(game) { |
| const center = ['d4', 'd5', 'e4', 'e5']; |
| let control = 0; |
| |
| center.forEach(square => { |
| const piece = game.get(square); |
| if (piece) { |
| control += piece.color === 'w' ? 1 : -1; |
| } |
| }); |
| |
| return control; |
| } |
| |
| |
| function normalizeGameForExport(game) { |
| const normalized = { |
| id: String(game.id || `game_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`), |
| pgn: String(game.pgn || ''), |
| moves: Array.isArray(game.moves) ? game.moves.map(m => typeof m === 'object' ? m : {san: String(m)}) : [], |
| result: String(game.result || 'draw'), |
| positions: Array.isArray(game.positions) ? game.positions : [], |
| metadata: typeof game.metadata === 'object' ? game.metadata : {}, |
| start_time: String(game.start_time || new Date().toISOString()), |
| end_time: String(game.end_time || new Date().toISOString()), |
| moves_count: Number.isInteger(game.moves_count) ? game.moves_count : (Array.isArray(game.moves) ? game.moves.length : 0), |
| final_fen: String(game.final_fen || ''), |
| agent_metadata: typeof game.agent_metadata === 'object' ? game.agent_metadata : {} |
| }; |
| |
| if (isNaN(normalized.moves_count)) normalized.moves_count = 0; |
| |
| return normalized; |
| } |
| |
| |
| class ChessNeuralNetwork { |
| constructor(name, color, learningRate = 0.001) { |
| this.name = name; |
| this.color = color; |
| this.learningRate = learningRate; |
| this.model = null; |
| this.optimizer = tf.train.adam(learningRate); |
| this.lossHistory = []; |
| this.initializeModel(); |
| } |
| |
| initializeModel() { |
| this.model = tf.sequential(); |
| |
| this.model.add(tf.layers.dense({ |
| units: 128, |
| activation: 'relu', |
| inputShape: [896] |
| })); |
| |
| this.model.add(tf.layers.dense({ units: 64, activation: 'relu' })); |
| this.model.add(tf.layers.dropout({ rate: 0.2 })); |
| this.model.add(tf.layers.dense({ units: 32, activation: 'relu' })); |
| |
| this.model.add(tf.layers.dense({ units: 1, activation: 'tanh' })); |
| |
| this.model.compile({ |
| optimizer: this.optimizer, |
| loss: 'meanSquaredError', |
| metrics: ['accuracy'] |
| }); |
| |
| logAgent(this.color, `Neural network initialized (LR: ${this.learningRate})`, 'success'); |
| } |
| |
| async predict(boardState) { |
| const input = tf.tensor2d([boardState]); |
| const prediction = this.model.predict(input); |
| const value = await prediction.data(); |
| tf.dispose([input, prediction]); |
| return value[0]; |
| } |
| |
| async train(states, targets) { |
| if (states.length === 0) return 0; |
| |
| const xs = tf.tensor2d(states); |
| const ys = tf.tensor2d(targets, [targets.length, 1]); |
| |
| const history = await this.model.fit(xs, ys, { |
| epochs: 1, |
| batchSize: Math.min(32, states.length), |
| verbose: 0 |
| }); |
| |
| const loss = history.history.loss[0]; |
| this.lossHistory.push(loss); |
| |
| tf.dispose([xs, ys]); |
| return loss; |
| } |
| |
| updateLearningRate(newRate) { |
| this.learningRate = newRate; |
| this.optimizer.setLearningRate(newRate); |
| } |
| |
| async getWeightsData() { |
| if (!this.model) return null; |
| |
| const weights = this.model.getWeights(); |
| const weightsData = []; |
| |
| for (const tensor of weights) { |
| const data = await tensor.data(); |
| weightsData.push({ |
| shape: Array.from(tensor.shape), |
| data: Array.from(data), |
| dtype: tensor.dtype |
| }); |
| } |
| |
| return weightsData; |
| } |
| } |
| |
| |
| class RLAgent { |
| constructor(color, neuralNetwork) { |
| this.color = color; |
| this.nn = neuralNetwork; |
| this.memory = []; |
| this.experienceSize = 1000; |
| this.batchSize = 32; |
| this.gamma = 0.95; |
| this.lastAction = null; |
| } |
| |
| async selectMove(game, explorationRate = 0.3) { |
| const moves = game.moves(); |
| if (moves.length === 0) return null; |
| |
| if (Math.random() < explorationRate) { |
| const randomMove = moves[Math.floor(Math.random() * moves.length)]; |
| logAgent(this.color, `Exploration: ${randomMove}`, 'info'); |
| return randomMove; |
| } |
| |
| let bestMove = null; |
| let bestValue = -Infinity; |
| |
| for (const move of moves) { |
| const testGame = new Chess(game.fen()); |
| testGame.move(move); |
| |
| const state = encodeBoardState(testGame); |
| const value = await this.nn.predict(state); |
| |
| const adjustedValue = this.color === 'green' ? value : -value; |
| |
| if (adjustedValue > bestValue) { |
| bestValue = adjustedValue; |
| bestMove = move; |
| } |
| } |
| |
| if (bestMove) { |
| logAgent(this.color, `Best move: ${bestMove} (value: ${bestValue.toFixed(3)})`, 'info'); |
| } |
| |
| return bestMove || moves[0]; |
| } |
| |
| addExperience(state, action, reward, nextState, done) { |
| this.memory.push({ |
| state, |
| action, |
| reward, |
| nextState, |
| done, |
| timestamp: new Date().toISOString() |
| }); |
| if (this.memory.length > this.experienceSize) { |
| this.memory.shift(); |
| } |
| } |
| |
| async trainFromMemory() { |
| if (this.memory.length < this.batchSize) return 0; |
| |
| const batch = []; |
| const batchSize = Math.min(this.batchSize, this.memory.length); |
| for (let i = 0; i < batchSize; i++) { |
| const index = Math.floor(Math.random() * this.memory.length); |
| batch.push(this.memory[index]); |
| } |
| |
| const states = []; |
| const targets = []; |
| |
| for (const exp of batch) { |
| const currentQ = await this.nn.predict(exp.state); |
| let targetQ = exp.reward; |
| |
| if (!exp.done) { |
| const nextQ = await this.nn.predict(exp.nextState); |
| targetQ += this.gamma * nextQ; |
| } |
| |
| states.push(exp.state); |
| targets.push(targetQ); |
| } |
| |
| const loss = await this.nn.train(states, targets); |
| |
| if (loss < 10) { |
| state.agentStats[this.color].lossHistory.push(loss); |
| if (state.agentStats[this.color].lossHistory.length > 100) { |
| state.agentStats[this.color].lossHistory.shift(); |
| } |
| } |
| |
| return loss; |
| } |
| } |
| |
| |
| function encodeBoardState(game) { |
| const board = game.board(); |
| const encoded = new Array(896).fill(0); |
| |
| for (let rank = 0; rank < 8; rank++) { |
| for (let file = 0; file < 8; file++) { |
| const piece = board[rank][file]; |
| const baseIndex = (rank * 8 + file) * 14; |
| |
| if (piece) { |
| const pieceIndex = { |
| 'p': 0, 'n': 1, 'b': 2, 'r': 3, 'q': 4, 'k': 5, |
| 'P': 6, 'N': 7, 'B': 8, 'R': 9, 'Q': 10, 'K': 11 |
| }[piece.type + (piece.color === 'w' ? piece.type.toUpperCase() : piece.type)]; |
| |
| if (pieceIndex !== undefined) { |
| encoded[baseIndex + pieceIndex] = 1; |
| } |
| encoded[baseIndex + 12] = piece.color === 'w' ? 1 : 0; |
| encoded[baseIndex + 13] = 1; |
| } |
| } |
| } |
| |
| return encoded; |
| } |
| |
| |
| function updateQuantumBackground() { |
| const canvas = document.getElementById('quantum-field'); |
| if (!canvas) return; |
| |
| const ctx = canvas.getContext('2d'); |
| |
| canvas.width = window.innerWidth; |
| canvas.height = window.innerHeight; |
| |
| function draw() { |
| ctx.fillStyle = 'rgba(10, 10, 10, 0.1)'; |
| ctx.fillRect(0, 0, canvas.width, canvas.height); |
| |
| const time = Date.now() * 0.001; |
| const particleCount = 50; |
| |
| for (let i = 0; i < particleCount; i++) { |
| const x = (Math.sin(time + i * 0.1) * 0.5 + 0.5) * canvas.width; |
| const y = (Math.cos(time * 0.7 + i * 0.05) * 0.5 + 0.5) * canvas.height; |
| const size = 2 + Math.sin(time + i) * 1; |
| const hue = (i * 3 + time * 50) % 360; |
| |
| ctx.beginPath(); |
| ctx.arc(x, y, size, 0, Math.PI * 2); |
| ctx.fillStyle = `hsla(${hue}, 100%, 50%, 0.3)`; |
| ctx.fill(); |
| } |
| |
| requestAnimationFrame(draw); |
| } |
| |
| draw(); |
| } |
| |
| function visualizeNeuralNetwork(containerId, agentColor) { |
| const container = document.getElementById(containerId); |
| if (!container) return; |
| |
| container.innerHTML = ''; |
| |
| const layerSizes = [896, 128, 64, 32, 1]; |
| const width = container.clientWidth; |
| const height = container.clientHeight; |
| const layerSpacing = width / (layerSizes.length + 1); |
| |
| for (let l = 0; l < layerSizes.length; l++) { |
| const layerDiv = document.createElement('div'); |
| layerDiv.className = 'nn-layer'; |
| layerDiv.style.left = `${(l + 1) * layerSpacing}px`; |
| |
| const neurons = Math.min(layerSizes[l], 12); |
| const neuronSpacing = height / (neurons + 1); |
| |
| for (let n = 0; n < neurons; n++) { |
| const neuron = document.createElement('div'); |
| neuron.className = 'neuron'; |
| neuron.style.top = `${neuronSpacing * (n + 1)}px`; |
| |
| if (Math.random() > 0.5) { |
| neuron.classList.add('active'); |
| neuron.style.animationDelay = `${Math.random() * 2}s`; |
| } |
| |
| layerDiv.appendChild(neuron); |
| } |
| |
| container.appendChild(layerDiv); |
| } |
| |
| setInterval(() => { |
| const neurons = container.querySelectorAll('.neuron'); |
| neurons.forEach(neuron => { |
| if (Math.random() > 0.7) { |
| neuron.classList.toggle('active'); |
| neuron.style.animationDelay = `${Math.random() * 2}s`; |
| } |
| }); |
| }, 1000); |
| } |
| |
| function renderChessBoard() { |
| const board = document.getElementById('chess-board'); |
| if (!board || !state.game) return; |
| |
| board.innerHTML = ''; |
| |
| const files = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']; |
| const ranks = [8, 7, 6, 5, 4, 3, 2, 1]; |
| |
| for (let rank = 0; rank < 8; rank++) { |
| for (let file = 0; file < 8; file++) { |
| const square = files[file] + ranks[rank]; |
| const piece = state.game.get(square); |
| |
| const div = document.createElement('div'); |
| div.className = `chess-square ${(file + rank) % 2 === 0 ? 'light' : 'dark'}`; |
| div.dataset.square = square; |
| |
| if (piece) { |
| div.textContent = getPieceSymbol(piece.type, piece.color); |
| } |
| |
| board.appendChild(div); |
| } |
| } |
| |
| const history = state.game.history(); |
| document.getElementById('current-moves').textContent = history.length; |
| |
| const turn = state.game.turn() === 'w' ? 'Green' : 'Black'; |
| document.getElementById('current-turn').textContent = `${turn} to move`; |
| } |
| |
| function getPieceSymbol(type, color) { |
| const symbols = { |
| p: { w: '♙', b: '♟' }, |
| n: { w: '♘', b: '♞' }, |
| b: { w: '♗', b: '♝' }, |
| r: { w: '♖', b: '♜' }, |
| q: { w: '♕', b: '♛' }, |
| k: { w: '♔', b: '♚' } |
| }; |
| return symbols[type][color]; |
| } |
| |
| |
| async function startTraining() { |
| if (state.trainingActive) return; |
| |
| state.trainingActive = true; |
| state.trainingStartTime = Date.now(); |
| |
| document.getElementById('start-btn').style.display = 'none'; |
| document.getElementById('pause-btn').style.display = 'inline-block'; |
| |
| log('Starting neural network training session...', 'success'); |
| log('Two RL agents will play chess against each other', 'info'); |
| log('Left: Black Agent (Policy Network)', 'info'); |
| log('Right: Green Agent (Value Network)', 'info'); |
| |
| startTrainingTimer(); |
| startNewGame(); |
| |
| startRealTimeMonitoring(); |
| } |
| |
| async function trainingStep() { |
| if (!state.trainingActive) return; |
| |
| try { |
| if (state.game.game_over()) { |
| saveCurrentGame(); |
| updateAllMetrics(); |
| startNewGame(); |
| return; |
| } |
| |
| const currentColor = state.game.turn(); |
| const agentColor = currentColor === 'w' ? 'green' : 'black'; |
| const agent = state.agents[agentColor]; |
| |
| const currentState = encodeBoardState(state.game); |
| const explorationRate = state.agentStats[agentColor].explorationRate; |
| const move = await agent.selectMove(state.game, explorationRate); |
| |
| if (!move) { |
| log(`No valid moves for ${agentColor}`, 'warning'); |
| saveCurrentGame(); |
| startNewGame(); |
| return; |
| } |
| |
| const result = state.game.move(move); |
| if (!result) { |
| log(`Invalid move ${move} from ${agentColor}`, 'error'); |
| saveCurrentGame(); |
| startNewGame(); |
| return; |
| } |
| |
| state.agentStats[agentColor].movesMade++; |
| state.totalMoves++; |
| |
| const nextState = encodeBoardState(state.game); |
| const gameResult = evaluateGameResult(state.game); |
| |
| let reward = 0; |
| |
| if (state.game.game_over()) { |
| if (gameResult === agentColor) reward = 1; |
| else if (gameResult === 'draw') reward = 0.1; |
| else if (gameResult && gameResult !== agentColor) reward = -1; |
| } else { |
| const materialDiff = calculateMaterialAdvantage(state.game); |
| reward = materialDiff * 0.01; |
| |
| const centerControl = calculateCenterControl(state.game); |
| reward += centerControl * 0.005; |
| |
| const mobility = state.game.moves().length; |
| reward += mobility * 0.001; |
| |
| if (state.game.in_check()) { |
| reward += (agentColor === 'green' ? 0.05 : -0.05); |
| } |
| } |
| |
| agent.addExperience( |
| currentState, |
| move, |
| reward, |
| nextState, |
| state.game.game_over() |
| ); |
| |
| const loss = await agent.trainFromMemory(); |
| if (loss > 0) { |
| logAgent(agentColor, `Trained (loss: ${loss.toFixed(4)})`, 'info'); |
| } |
| |
| if (state.currentGameData) { |
| state.currentGameData.moves.push({ |
| san: move, |
| color: currentColor, |
| turn: state.currentGameData.moves.length + 1, |
| timestamp: new Date().toISOString(), |
| reward: reward, |
| fen: state.game.fen() |
| }); |
| state.currentGameData.positions.push(state.game.fen()); |
| } |
| |
| renderChessBoard(); |
| updateAllMetrics(); |
| |
| setTimeout(trainingStep, 100); |
| |
| } catch (error) { |
| console.error("Training error:", error); |
| log(`Training error: ${error.message}`, 'error'); |
| pauseTraining(); |
| } |
| } |
| |
| function startNewGame() { |
| state.game = new Chess(); |
| state.currentGameNumber++; |
| |
| state.currentGameData = { |
| id: `game_${state.currentGameNumber}_${Date.now()}`, |
| pgn: '', |
| moves: [], |
| positions: [state.game.fen()], |
| start_time: new Date().toISOString(), |
| metadata: { |
| black_lr: state.agentStats.black.learningRate, |
| green_lr: state.agentStats.green.learningRate, |
| black_explore: state.agentStats.black.explorationRate, |
| green_explore: state.agentStats.green.explorationRate, |
| training_iteration: state.currentGameNumber |
| } |
| }; |
| |
| document.getElementById('current-game').textContent = state.currentGameNumber; |
| renderChessBoard(); |
| |
| log(`Starting game #${state.currentGameNumber}`, 'info'); |
| |
| if (state.trainingActive) { |
| setTimeout(trainingStep, 100); |
| } |
| } |
| |
| function saveCurrentGame() { |
| if (!state.currentGameData || !state.game) return; |
| |
| const history = state.game.history(); |
| if (state.currentGameData.moves.length !== history.length) { |
| state.currentGameData.moves = history.map((san, idx) => ({ |
| san, |
| color: idx % 2 === 0 ? 'w' : 'b', |
| turn: idx + 1, |
| timestamp: new Date().toISOString(), |
| fen: state.game.fen() |
| })); |
| } |
| |
| let result = 'draw'; |
| if (state.game.in_checkmate()) { |
| result = state.game.turn() === 'w' ? 'black' : 'green'; |
| } else if (state.game.in_draw() || state.game.in_stalemate()) { |
| result = 'draw'; |
| } else if (state.game.in_threefold_repetition()) { |
| result = 'draw'; |
| } else if (state.game.in_check()) { |
| result = state.game.turn() === 'w' ? 'black' : 'green'; |
| } |
| |
| state.currentGameData.final_fen = state.game.fen(); |
| state.currentGameData.result = result; |
| state.currentGameData.end_time = new Date().toISOString(); |
| state.currentGameData.moves_count = state.currentGameData.moves.length; |
| state.currentGameData.pgn = state.game.pgn(); |
| |
| state.currentGameData.agent_metadata = { |
| black: { |
| learning_rate: state.agentStats.black.learningRate, |
| exploration_rate: state.agentStats.black.explorationRate, |
| loss: state.agentStats.black.lossHistory.slice(-1)[0] || 0, |
| total_moves: state.agentStats.black.movesMade, |
| total_games: state.agentStats.black.totalGames |
| }, |
| green: { |
| learning_rate: state.agentStats.green.learningRate, |
| exploration_rate: state.agentStats.green.explorationRate, |
| loss: state.agentStats.green.lossHistory.slice(-1)[0] || 0, |
| total_moves: state.agentStats.green.movesMade, |
| total_games: state.agentStats.green.totalGames |
| } |
| }; |
| |
| if (validateGameData(state.currentGameData)) { |
| const normalizedGame = normalizeGameForExport(state.currentGameData); |
| state.dataset.push(normalizedGame); |
| state.validGames++; |
| |
| if (result === 'green') { |
| state.agentStats.green.wins++; |
| state.agentStats.black.losses++; |
| } else if (result === 'black') { |
| state.agentStats.black.wins++; |
| state.agentStats.green.losses++; |
| } else { |
| state.agentStats.green.draws++; |
| state.agentStats.black.draws++; |
| } |
| |
| state.agentStats.green.totalGames++; |
| state.agentStats.black.totalGames++; |
| |
| log(`Game ${state.currentGameNumber} completed: ${result} (${state.currentGameData.moves_count} moves)`, 'success'); |
| |
| if (state.validGames % 10 === 0) { |
| log(`Auto-collected ${state.validGames} games`, 'info'); |
| } |
| } else { |
| log(`Game ${state.currentGameNumber} invalid - discarded`, 'warning'); |
| } |
| } |
| |
| function evaluateGameResult(game) { |
| if (game.in_checkmate()) { |
| return game.turn() === 'w' ? 'black' : 'green'; |
| } |
| if (game.in_draw() || game.in_stalemate() || game.in_threefold_repetition()) { |
| return 'draw'; |
| } |
| return null; |
| } |
| |
| function validateGameData(gameData) { |
| try { |
| if (!gameData || typeof gameData !== 'object') return false; |
| if (!gameData.moves || !Array.isArray(gameData.moves)) return false; |
| if (!gameData.result || !['black', 'green', 'draw'].includes(gameData.result)) return false; |
| |
| if (gameData.moves.length > 0) { |
| const testGame = new Chess(); |
| |
| for (let i = 0; i < gameData.moves.length; i++) { |
| const move = gameData.moves[i]; |
| if (!testGame.move(move.san)) { |
| log(`Move ${i+1} invalid: ${move.san}`, 'warning'); |
| } |
| } |
| } |
| |
| return gameData.moves_count === gameData.moves.length && |
| gameData.id && |
| gameData.start_time; |
| } catch (error) { |
| log(`Validation error: ${error.message}`, 'warning'); |
| return false; |
| } |
| } |
| |
| function pauseTraining() { |
| state.trainingActive = false; |
| document.getElementById('start-btn').style.display = 'inline-block'; |
| document.getElementById('pause-btn').style.display = 'none'; |
| |
| if (state.trainingTimer) { |
| clearInterval(state.trainingTimer); |
| state.trainingTimer = null; |
| } |
| |
| stopRealTimeMonitoring(); |
| |
| log('Training paused', 'warning'); |
| } |
| |
| function resetTraining() { |
| if (state.trainingActive) { |
| pauseTraining(); |
| } |
| |
| state.game = new Chess(); |
| state.currentGameNumber = 1; |
| state.dataset = []; |
| state.validGames = 0; |
| state.totalMoves = 0; |
| state.currentGameData = null; |
| state.lastAutoSave = null; |
| |
| state.agentStats = { |
| black: { |
| wins: 0, |
| losses: 0, |
| draws: 0, |
| totalGames: 0, |
| movesMade: 0, |
| learningRate: 0.001, |
| explorationRate: 0.3, |
| discountFactor: 0.95, |
| lossHistory: [] |
| }, |
| green: { |
| wins: 0, |
| losses: 0, |
| draws: 0, |
| totalGames: 0, |
| movesMade: 0, |
| learningRate: 0.001, |
| explorationRate: 0.3, |
| discountFactor: 0.95, |
| lossHistory: [] |
| } |
| }; |
| |
| initializeNeuralNetworks(); |
| |
| renderChessBoard(); |
| updateAllMetrics(); |
| |
| document.getElementById('current-game').textContent = '1'; |
| document.getElementById('current-moves').textContent = '0'; |
| document.getElementById('training-timer').textContent = '00:00:00'; |
| |
| log('Training completely reset - all data cleared', 'success'); |
| } |
| |
| |
| function startRealTimeMonitoring() { |
| if (state.realTimeInterval) { |
| clearInterval(state.realTimeInterval); |
| } |
| |
| state.realTimeInterval = setInterval(() => { |
| if (state.trainingActive) { |
| updateAllMetrics(); |
| |
| if (Date.now() - (state.lastAutoSave || 0) > 5 * 60 * 1000) { |
| saveState(); |
| state.lastAutoSave = Date.now(); |
| log('Auto-saved training state', 'info'); |
| } |
| |
| const progress = Math.min(100, (state.totalMoves % 1000) / 10); |
| const progressBar = document.getElementById('training-progress'); |
| if (progressBar) { |
| progressBar.style.width = `${progress}%`; |
| } |
| } |
| }, 1000); |
| } |
| |
| function stopRealTimeMonitoring() { |
| if (state.realTimeInterval) { |
| clearInterval(state.realTimeInterval); |
| state.realTimeInterval = null; |
| } |
| } |
| |
| |
| function updateAgentParam(agent, param, value) { |
| if (!state.agentStats[agent]) return; |
| |
| state.agentStats[agent][param] = value; |
| |
| if (param === 'learningRate' && state.neuralNetworks[agent]) { |
| state.neuralNetworks[agent].updateLearningRate(value); |
| } |
| |
| const elementId = `${agent}-${param}-value`; |
| const element = document.getElementById(elementId); |
| if (element) { |
| element.textContent = param === 'learningRate' ? value.toFixed(4) : value.toFixed(2); |
| } |
| |
| logAgent(agent, `${param} set to ${value}`, 'info'); |
| updateAllMetrics(); |
| } |
| |
| function updateAllMetrics() { |
| |
| const blackTotal = Math.max(1, state.agentStats.black.totalGames); |
| const blackWinRate = (state.agentStats.black.wins / blackTotal * 100).toFixed(1); |
| const blackLoss = state.agentStats.black.lossHistory.length > 0 ? |
| state.agentStats.black.lossHistory.slice(-1)[0].toFixed(3) : '0.000'; |
| |
| document.getElementById('black-win-rate').innerHTML = `${blackWinRate}<span class="metric-unit">%</span>`; |
| document.getElementById('black-loss').textContent = blackLoss; |
| document.getElementById('black-lr').textContent = state.agentStats.black.learningRate.toFixed(4); |
| document.getElementById('black-explore').textContent = state.agentStats.black.explorationRate.toFixed(2); |
| document.getElementById('black-games').textContent = state.agentStats.black.totalGames; |
| document.getElementById('black-moves').textContent = state.agentStats.black.movesMade; |
| |
| |
| const greenTotal = Math.max(1, state.agentStats.green.totalGames); |
| const greenWinRate = (state.agentStats.green.wins / greenTotal * 100).toFixed(1); |
| const greenLoss = state.agentStats.green.lossHistory.length > 0 ? |
| state.agentStats.green.lossHistory.slice(-1)[0].toFixed(3) : '0.000'; |
| |
| document.getElementById('green-win-rate').innerHTML = `${greenWinRate}<span class="metric-unit">%</span>`; |
| document.getElementById('green-loss').textContent = greenLoss; |
| document.getElementById('green-lr').textContent = state.agentStats.green.learningRate.toFixed(4); |
| document.getElementById('green-explore').textContent = state.agentStats.green.explorationRate.toFixed(2); |
| document.getElementById('green-games').textContent = state.agentStats.green.totalGames; |
| document.getElementById('green-moves').textContent = state.agentStats.green.movesMade; |
| |
| |
| document.getElementById('total-games').textContent = state.validGames; |
| document.getElementById('total-moves').textContent = state.totalMoves; |
| |
| |
| const progress = Math.min(100, (state.totalMoves % 1000) / 10); |
| const progressBar = document.getElementById('training-progress'); |
| if (progressBar) { |
| progressBar.style.width = `${progress}%`; |
| } |
| } |
| |
| function startTrainingTimer() { |
| let seconds = 0; |
| |
| if (state.trainingTimer) { |
| clearInterval(state.trainingTimer); |
| } |
| |
| state.trainingTimer = setInterval(() => { |
| seconds++; |
| const hours = Math.floor(seconds / 3600); |
| const minutes = Math.floor((seconds % 3600) / 60); |
| const secs = seconds % 60; |
| |
| document.getElementById('training-timer').textContent = |
| `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`; |
| }, 1000); |
| } |
| |
| |
| function log(message, type = 'info') { |
| const terminal = document.getElementById('main-terminal'); |
| if (!terminal) return; |
| |
| const line = document.createElement('div'); |
| line.className = `terminal-line ${type}`; |
| line.textContent = `[${new Date().toLocaleTimeString()}] ${message}`; |
| terminal.appendChild(line); |
| |
| if (terminal.children.length > 100) { |
| terminal.removeChild(terminal.firstChild); |
| } |
| |
| terminal.scrollTop = terminal.scrollHeight; |
| } |
| |
| function logAgent(agent, message, type = 'info') { |
| const logContent = document.getElementById(`${agent}-log-content`); |
| const logCount = document.getElementById(`${agent}-log-count`); |
| |
| if (!logContent || !logCount) return; |
| |
| const line = document.createElement('div'); |
| line.className = `log-line ${type}`; |
| line.textContent = `[${new Date().toLocaleTimeString()}] ${message}`; |
| logContent.appendChild(line); |
| |
| const count = logContent.children.length; |
| logCount.textContent = count; |
| |
| if (count > 50) { |
| logContent.removeChild(logContent.firstChild); |
| } |
| |
| logContent.scrollTop = logContent.scrollHeight; |
| } |
| |
| |
| async function exportEverything() { |
| log('Starting export of all training data and models...', 'info'); |
| |
| try { |
| |
| const zip = new JSZip(); |
| |
| |
| if (state.dataset.length > 0) { |
| log(`Exporting ${state.dataset.length} training games...`, 'info'); |
| const gamesData = JSON.stringify(state.dataset, null, 2); |
| zip.file("training_games.json", gamesData); |
| |
| |
| const csvHeader = "id,pgn,result,moves_count,start_time,end_time,final_fen\n"; |
| const csvRows = state.dataset.map(g => |
| `"${g.id}","${g.pgn.replace(/"/g, '""')}","${g.result}",${g.moves_count},"${g.start_time}","${g.end_time}","${g.final_fen}"` |
| ).join('\n'); |
| zip.file("training_games.csv", csvHeader + csvRows); |
| } else { |
| log('No training games to export', 'warning'); |
| } |
| |
| // 2. Export neural network models |
| log('Exporting neural network models...', 'info'); |
| |
| // Black agent model |
| if (state.neuralNetworks.black) { |
| const blackModelData = { |
| model_type: "chess_policy_network", |
| color: "black", |
| architecture: { |
| input_size: 896, |
| hidden_layers: [128, 64, 32], |
| output_size: 1, |
| activation: ["relu", "relu", "relu", "tanh"], |
| dropout: 0.2 |
| }, |
| hyperparameters: { |
| learning_rate: state.agentStats.black.learningRate, |
| exploration_rate: state.agentStats.black.explorationRate, |
| discount_factor: state.agentStats.black.discountFactor |
| }, |
| training_stats: { |
| wins: state.agentStats.black.wins, |
| losses: state.agentStats.black.losses, |
| draws: state.agentStats.black.draws, |
| total_games: state.agentStats.black.totalGames, |
| moves_made: state.agentStats.black.movesMade |
| }, |
| export_timestamp: new Date().toISOString() |
| }; |
| |
| zip.file("black_agent_model.json", JSON.stringify(blackModelData, null, 2)); |
| } |
| |
| // Green agent model |
| if (state.neuralNetworks.green) { |
| const greenModelData = { |
| model_type: "chess_value_network", |
| color: "green", |
| architecture: { |
| input_size: 896, |
| hidden_layers: [128, 64, 32], |
| output_size: 1, |
| activation: ["relu", "relu", "relu", "tanh"], |
| dropout: 0.2 |
| }, |
| hyperparameters: { |
| learning_rate: state.agentStats.green.learningRate, |
| exploration_rate: state.agentStats.green.explorationRate, |
| discount_factor: state.agentStats.green.discountFactor |
| }, |
| training_stats: { |
| wins: state.agentStats.green.wins, |
| losses: state.agentStats.green.losses, |
| draws: state.agentStats.green.draws, |
| total_games: state.agentStats.green.totalGames, |
| moves_made: state.agentStats.green.movesMade |
| }, |
| export_timestamp: new Date().toISOString() |
| }; |
| |
| zip.file("green_agent_model.json", JSON.stringify(greenModelData, null, 2)); |
| } |
| |
| // 3. Export training statistics |
| log('Exporting training statistics...', 'info'); |
| const statsData = { |
| training_summary: { |
| total_games: state.validGames, |
| total_moves: state.totalMoves, |
| training_time: document.getElementById('training-timer').textContent, |
| current_game: state.currentGameNumber, |
| training_active: state.trainingActive |
| }, |
| agent_comparison: { |
| black_win_rate: ((state.agentStats.black.wins / Math.max(1, state.agentStats.black.totalGames)) * 100).toFixed(1), |
| green_win_rate: ((state.agentStats.green.wins / Math.max(1, state.agentStats.green.totalGames)) * 100).toFixed(1), |
| draws_rate: ((state.agentStats.black.draws / Math.max(1, state.agentStats.black.totalGames)) * 100).toFixed(1) |
| }, |
| export_timestamp: new Date().toISOString(), |
| system_info: { |
| user_agent: navigator.userAgent, |
| platform: navigator.platform, |
| screen_resolution: `${window.screen.width}x${window.screen.height}` |
| } |
| }; |
| |
| zip.file("training_statistics.json", JSON.stringify(statsData, null, 2)); |
| |
| // 4. Create README file |
| log('Creating documentation...', 'info'); |
| const readme = `# Chess RL Training Export |
| |
| ## Export Information |
| - Export Date: ${new Date().toISOString()} |
| - Total Training Games: ${state.validGames} |
| - Total Moves: ${state.totalMoves} |
| - Training Time: ${document.getElementById('training-timer').textContent} |
| |
| ## Files Included |
| |
| ### 1. training_games.json |
| Complete dataset of all chess games played during training. Each game includes: |
| - Full PGN notation |
| - Move-by-move records |
| - Game result and metadata |
| - Agent parameters for each game |
| |
| ### 2. training_games.csv |
| Same data as JSON but in CSV format for easy import into spreadsheets or databases. |
| |
| ### 3. black_agent_model.json |
| Black Agent (Policy Network) configuration and statistics: |
| - Neural network architecture |
| - Hyperparameters (learning rate, exploration rate, etc.) |
| - Training statistics (wins, losses, draws) |
| - Model metadata |
| |
| ### 4. green_agent_model.json |
| Green Agent (Value Network) configuration and statistics: |
| - Neural network architecture |
| - Hyperparameters |
| - Training statistics |
| - Model metadata |
| |
| ### 5. training_statistics.json |
| Overall training summary and statistics including: |
| - Training duration |
| - Win rates for both agents |
| - System information |
| - Export metadata |
| |
| ## Training System |
| Generated by ANN Chess RL Trainer v3.0 - A web-based reinforcement learning system for chess AI development. |
| |
| ## Usage |
| These files can be used to: |
| - Continue training from this point |
| - Analyze the learning progress |
| - Import into other machine learning frameworks |
| - Share with the research community |
| |
| ## Notes |
| - All data is in standard JSON/CSV formats |
| - Compatible with Hugging Face datasets |
| - Can be compressed with GZIP, ZSTD, BZ2, LZ4, or LZMA for upload |
| `; |
| |
| zip.file("README.md", readme); |
| |
| // 5. Generate and download ZIP |
| log('Generating ZIP archive...', 'info'); |
| const content = await zip.generateAsync({ |
| type: "blob", |
| compression: "DEFLATE", |
| compressionOptions: { |
| level: 6 |
| } |
| }); |
| |
| const timestamp = new Date().toISOString().replace(/[:.]/g, '-'); |
| const filename = `chess_rl_training_export_${timestamp}.zip`; |
| const url = URL.createObjectURL(content); |
| const a = document.createElement('a'); |
| a.href = url; |
| a.download = filename; |
| document.body.appendChild(a); |
| a.click(); |
| document.body.removeChild(a); |
| URL.revokeObjectURL(url); |
| |
| log(`Export completed successfully! File: ${filename}`, 'success'); |
| log('The ZIP file contains all training data, models, and statistics.', 'info'); |
| |
| } catch (error) { |
| console.error('Export error:', error); |
| log(`Export failed: ${error.message}`, 'error'); |
| } |
| } |
| |
| function saveState() { |
| const stateData = { |
| agentStats: state.agentStats, |
| dataset: state.dataset.slice(-50), |
| validGames: state.validGames, |
| totalMoves: state.totalMoves, |
| currentGame: { |
| number: state.currentGameNumber, |
| fen: state.game ? state.game.fen() : null |
| }, |
| timestamp: new Date().toISOString(), |
| training_time: document.getElementById('training-timer').textContent |
| }; |
| |
| const blob = new Blob([JSON.stringify(stateData, null, 2)], { type: 'application/json' }); |
| const url = URL.createObjectURL(blob); |
| const a = document.createElement('a'); |
| a.href = url; |
| a.download = `chess_rl_state_${Date.now()}.json`; |
| a.click(); |
| URL.revokeObjectURL(url); |
| |
| state.lastAutoSave = Date.now(); |
| log('Training state saved locally', 'success'); |
| } |
| |
| // Initialization |
| async function initializeNeuralNetworks() { |
| log('Initializing neural networks...', 'info'); |
| |
| state.neuralNetworks.black = new ChessNeuralNetwork('BlackAgent', 'black', state.agentStats.black.learningRate); |
| state.neuralNetworks.green = new ChessNeuralNetwork('GreenAgent', 'green', state.agentStats.green.learningRate); |
| |
| state.agents.black = new RLAgent('black', state.neuralNetworks.black); |
| state.agents.green = new RLAgent('green', state.neuralNetworks.green); |
| |
| state.game = new Chess(); |
| |
| visualizeNeuralNetwork('black-nn-viz', 'black'); |
| visualizeNeuralNetwork('green-nn-viz', 'green'); |
| |
| log('Neural networks initialized successfully', 'success'); |
| logAgent('black', 'Neural network ready', 'success'); |
| logAgent('green', 'Neural network ready', 'success'); |
| } |
| |
| async function init() { |
| const loadingBar = document.querySelector('.loading-bar'); |
| const loadingDetails = document.getElementById('loading-details'); |
| |
| const steps = [ |
| 'Loading TensorFlow.js...', |
| 'Initializing neural networks...', |
| 'Setting up RL agents...', |
| 'Preparing visualization...', |
| 'Starting training environment...' |
| ]; |
| |
| for (let i = 0; i < steps.length; i++) { |
| if (loadingDetails) { |
| loadingDetails.textContent = steps[i]; |
| } |
| if (loadingBar) { |
| loadingBar.style.width = `${((i + 1) / steps.length) * 100}%`; |
| } |
| await new Promise(resolve => setTimeout(resolve, 300)); |
| } |
| |
| try { |
| await initializeNeuralNetworks(); |
| updateQuantumBackground(); |
| renderChessBoard(); |
| updateAllMetrics(); |
| |
| document.getElementById('loading-screen').style.display = 'none'; |
| document.querySelector('.container').style.opacity = '1'; |
| |
| log('ANN Chess RL Trainer v3.0 ready!', 'success'); |
| log('Left: Black Agent (Policy Network)', 'info'); |
| log('Right: Green Agent (Value Network)', 'info'); |
| log('Click "Start Training" to begin reinforcement learning', 'info'); |
| log('Click "Export All" to download everything as a ZIP file', 'info'); |
| log('ZIP includes: games, models, statistics in JSON/CSV formats', 'info'); |
| |
| } catch (error) { |
| log(`Initialization failed: ${error.message}`, 'error'); |
| console.error(error); |
| } |
| } |
| |
| // Initialize on load |
| window.addEventListener('load', init); |
| window.addEventListener('resize', updateQuantumBackground); |
| </script> |
| </body> |
| </html> |
