|
|
<!DOCTYPE html> |
|
|
<html lang="en"> |
|
|
<head> |
|
|
<meta charset="UTF-8"> |
|
|
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no"> |
|
|
<title>MATRIX/MA DATASETS - by webXOS</title> |
|
|
|
|
|
|
|
|
<link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;700&display=swap" rel="stylesheet"> |
|
|
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css"> |
|
|
<script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@latest"></script> |
|
|
<script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script> |
|
|
<script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script> |
|
|
|
|
|
<style> |
|
|
|
|
|
:root { |
|
|
--terminal-black: #000000; |
|
|
--terminal-green: #00FF00; |
|
|
--terminal-red: #FF0000; |
|
|
--terminal-gray: #1E1E1E; |
|
|
--terminal-light-gray: #2D2D2D; |
|
|
--terminal-medium-gray: #3A3A3A; |
|
|
--terminal-border: #7A7A7A; |
|
|
--terminal-yellow: #FFFF00; |
|
|
--terminal-blue: #0000FF; |
|
|
|
|
|
|
|
|
--clean-bg: rgba(10, 10, 12, 0.98); |
|
|
--clean-text: #E0E0E0; |
|
|
--clean-accent: #00FF88; |
|
|
--clean-border: #333344; |
|
|
--clean-header: rgba(20, 20, 30, 0.95); |
|
|
--hf-purple: #7C3AED; |
|
|
} |
|
|
|
|
|
* { |
|
|
margin: 0; |
|
|
padding: 0; |
|
|
box-sizing: border-box; |
|
|
font-family: 'JetBrains Mono', 'Courier New', monospace; |
|
|
-webkit-tap-highlight-color: transparent; |
|
|
} |
|
|
|
|
|
body { |
|
|
background-color: var(--terminal-black); |
|
|
color: var(--terminal-green); |
|
|
height: 100vh; |
|
|
overflow: hidden; |
|
|
display: flex; |
|
|
flex-direction: column; |
|
|
touch-action: manipulation; |
|
|
} |
|
|
|
|
|
|
|
|
.hf-window { |
|
|
position: fixed; |
|
|
top: 50%; |
|
|
left: 50%; |
|
|
transform: translate(-50%, -50%); |
|
|
width: 90%; |
|
|
max-width: 1200px; |
|
|
height: 85%; |
|
|
background: var(--clean-bg); |
|
|
border: 1px solid var(--clean-border); |
|
|
border-radius: 8px; |
|
|
box-shadow: 0 10px 50px rgba(0, 0, 0, 0.7); |
|
|
display: none; |
|
|
flex-direction: column; |
|
|
z-index: 10000; |
|
|
overflow: hidden; |
|
|
} |
|
|
|
|
|
.hf-window.active { |
|
|
display: flex; |
|
|
} |
|
|
|
|
|
.hf-header { |
|
|
background: var(--clean-header); |
|
|
padding: 12px 20px; |
|
|
border-bottom: 1px solid var(--clean-border); |
|
|
display: flex; |
|
|
justify-content: space-between; |
|
|
align-items: center; |
|
|
color: var(--clean-accent); |
|
|
font-weight: 500; |
|
|
} |
|
|
|
|
|
.hf-title { |
|
|
display: flex; |
|
|
align-items: center; |
|
|
gap: 10px; |
|
|
} |
|
|
|
|
|
.hf-title i { |
|
|
color: var(--hf-purple); |
|
|
} |
|
|
|
|
|
.hf-controls { |
|
|
display: flex; |
|
|
gap: 8px; |
|
|
} |
|
|
|
|
|
.hf-btn { |
|
|
background: rgba(124, 58, 237, 0.1); |
|
|
border: 1px solid rgba(124, 58, 237, 0.3); |
|
|
color: var(--hf-purple); |
|
|
padding: 6px 12px; |
|
|
border-radius: 4px; |
|
|
cursor: pointer; |
|
|
font-size: 0.8rem; |
|
|
transition: all 0.2s; |
|
|
} |
|
|
|
|
|
.hf-btn:hover { |
|
|
background: rgba(124, 58, 237, 0.2); |
|
|
} |
|
|
|
|
|
.hf-btn.primary { |
|
|
background: rgba(0, 255, 136, 0.1); |
|
|
border-color: rgba(0, 255, 136, 0.3); |
|
|
color: var(--clean-accent); |
|
|
} |
|
|
|
|
|
.hf-btn.danger { |
|
|
background: rgba(255, 0, 0, 0.1); |
|
|
border-color: rgba(255, 0, 0, 0.3); |
|
|
color: #ff6666; |
|
|
} |
|
|
|
|
|
.hf-btn.close { |
|
|
background: rgba(255, 0, 0, 0.1); |
|
|
border-color: rgba(255, 0, 0, 0.3); |
|
|
color: #ff6666; |
|
|
} |
|
|
|
|
|
.hf-container { |
|
|
flex: 1; |
|
|
display: flex; |
|
|
overflow: hidden; |
|
|
padding: 20px; |
|
|
gap: 20px; |
|
|
} |
|
|
|
|
|
.config-panel { |
|
|
flex: 1; |
|
|
display: flex; |
|
|
flex-direction: column; |
|
|
background: rgba(5, 5, 10, 0.8); |
|
|
border: 1px solid var(--clean-border); |
|
|
border-radius: 6px; |
|
|
overflow: hidden; |
|
|
min-width: 300px; |
|
|
} |
|
|
|
|
|
.config-header { |
|
|
padding: 10px 15px; |
|
|
background: rgba(15, 15, 25, 0.9); |
|
|
border-bottom: 1px solid var(--clean-border); |
|
|
color: var(--hf-purple); |
|
|
font-size: 0.85rem; |
|
|
display: flex; |
|
|
justify-content: space-between; |
|
|
align-items: center; |
|
|
} |
|
|
|
|
|
.config-content { |
|
|
flex: 1; |
|
|
padding: 15px; |
|
|
overflow-y: auto; |
|
|
color: var(--clean-text); |
|
|
} |
|
|
|
|
|
.config-section { |
|
|
margin-bottom: 20px; |
|
|
padding: 10px; |
|
|
background: rgba(20, 20, 30, 0.3); |
|
|
border-radius: 4px; |
|
|
} |
|
|
|
|
|
.section-title { |
|
|
color: var(--hf-purple); |
|
|
font-size: 0.9rem; |
|
|
margin-bottom: 10px; |
|
|
display: flex; |
|
|
align-items: center; |
|
|
gap: 8px; |
|
|
} |
|
|
|
|
|
.config-input { |
|
|
margin-bottom: 12px; |
|
|
} |
|
|
|
|
|
.config-input label { |
|
|
display: block; |
|
|
font-size: 0.8rem; |
|
|
color: var(--clean-text); |
|
|
margin-bottom: 4px; |
|
|
} |
|
|
|
|
|
.config-input input, .config-input select { |
|
|
width: 100%; |
|
|
background: rgba(30, 30, 40, 0.8); |
|
|
border: 1px solid var(--clean-border); |
|
|
color: var(--clean-text); |
|
|
padding: 6px 10px; |
|
|
border-radius: 3px; |
|
|
font-size: 0.8rem; |
|
|
} |
|
|
|
|
|
.config-input input:focus, .config-input select:focus { |
|
|
outline: 1px solid var(--hf-purple); |
|
|
} |
|
|
|
|
|
.slider-container { |
|
|
display: flex; |
|
|
align-items: center; |
|
|
gap: 10px; |
|
|
} |
|
|
|
|
|
.slider-value { |
|
|
min-width: 40px; |
|
|
text-align: center; |
|
|
font-size: 0.8rem; |
|
|
} |
|
|
|
|
|
input[type="range"] { |
|
|
flex: 1; |
|
|
height: 4px; |
|
|
background: rgba(30, 30, 40, 0.8); |
|
|
border-radius: 2px; |
|
|
outline: none; |
|
|
-webkit-appearance: none; |
|
|
} |
|
|
|
|
|
input[type="range"]::-webkit-slider-thumb { |
|
|
-webkit-appearance: none; |
|
|
width: 16px; |
|
|
height: 16px; |
|
|
background: var(--hf-purple); |
|
|
border-radius: 50%; |
|
|
cursor: pointer; |
|
|
} |
|
|
|
|
|
.checkbox-group { |
|
|
display: flex; |
|
|
flex-direction: column; |
|
|
gap: 6px; |
|
|
margin-top: 5px; |
|
|
} |
|
|
|
|
|
.checkbox-item { |
|
|
display: flex; |
|
|
align-items: center; |
|
|
gap: 6px; |
|
|
font-size: 0.8rem; |
|
|
} |
|
|
|
|
|
.checkbox-item input[type="checkbox"] { |
|
|
width: 14px; |
|
|
height: 14px; |
|
|
} |
|
|
|
|
|
.terminal-panel { |
|
|
flex: 2; |
|
|
display: flex; |
|
|
flex-direction: column; |
|
|
background: rgba(5, 5, 10, 0.8); |
|
|
border: 1px solid var(--clean-border); |
|
|
border-radius: 6px; |
|
|
overflow: hidden; |
|
|
} |
|
|
|
|
|
.terminal-header { |
|
|
padding: 10px 15px; |
|
|
background: rgba(15, 15, 25, 0.9); |
|
|
border-bottom: 1px solid var(--clean-border); |
|
|
color: var(--hf-purple); |
|
|
font-size: 0.85rem; |
|
|
display: flex; |
|
|
justify-content: space-between; |
|
|
align-items: center; |
|
|
} |
|
|
|
|
|
.terminal-output { |
|
|
flex: 1; |
|
|
padding: 15px; |
|
|
overflow-y: auto; |
|
|
font-size: 0.85rem; |
|
|
line-height: 1.4; |
|
|
color: var(--clean-text); |
|
|
} |
|
|
|
|
|
.terminal-line { |
|
|
margin-bottom: 3px; |
|
|
word-break: break-word; |
|
|
white-space: pre-wrap; |
|
|
animation: fadeIn 0.2s ease; |
|
|
} |
|
|
|
|
|
.terminal-line.command { |
|
|
color: var(--hf-purple); |
|
|
} |
|
|
|
|
|
.terminal-line.output { |
|
|
color: var(--clean-text); |
|
|
} |
|
|
|
|
|
.terminal-line.error { |
|
|
color: #ff6666; |
|
|
} |
|
|
|
|
|
.terminal-line.success { |
|
|
color: var(--clean-accent); |
|
|
} |
|
|
|
|
|
.terminal-line.info { |
|
|
color: #66ccff; |
|
|
} |
|
|
|
|
|
.terminal-line.warning { |
|
|
color: #ffcc00; |
|
|
} |
|
|
|
|
|
.terminal-line.hf { |
|
|
color: var(--hf-purple); |
|
|
} |
|
|
|
|
|
.terminal-input { |
|
|
padding: 10px 15px; |
|
|
background: rgba(15, 15, 25, 0.9); |
|
|
border-top: 1px solid var(--clean-border); |
|
|
display: flex; |
|
|
align-items: center; |
|
|
gap: 10px; |
|
|
} |
|
|
|
|
|
.input-prompt { |
|
|
color: var(--hf-purple); |
|
|
font-weight: bold; |
|
|
} |
|
|
|
|
|
#hfInput { |
|
|
flex: 1; |
|
|
background: transparent; |
|
|
border: none; |
|
|
color: var(--clean-text); |
|
|
font-family: 'JetBrains Mono', monospace; |
|
|
font-size: 0.9rem; |
|
|
outline: none; |
|
|
} |
|
|
|
|
|
.progress-container { |
|
|
margin-top: 15px; |
|
|
padding: 10px; |
|
|
background: rgba(20, 20, 30, 0.5); |
|
|
border-radius: 4px; |
|
|
border: 1px solid var(--clean-border); |
|
|
} |
|
|
|
|
|
.progress-header { |
|
|
display: flex; |
|
|
justify-content: space-between; |
|
|
margin-bottom: 8px; |
|
|
font-size: 0.8rem; |
|
|
} |
|
|
|
|
|
.progress-bar { |
|
|
height: 8px; |
|
|
background: rgba(30, 30, 40, 0.8); |
|
|
border-radius: 4px; |
|
|
overflow: hidden; |
|
|
} |
|
|
|
|
|
.progress-fill { |
|
|
height: 100%; |
|
|
background: linear-gradient(90deg, var(--hf-purple), var(--clean-accent)); |
|
|
transition: width 0.3s ease; |
|
|
width: 0%; |
|
|
} |
|
|
|
|
|
.progress-stats { |
|
|
display: grid; |
|
|
grid-template-columns: repeat(2, 1fr); |
|
|
gap: 8px; |
|
|
margin-top: 10px; |
|
|
font-size: 0.75rem; |
|
|
} |
|
|
|
|
|
.stat-item { |
|
|
display: flex; |
|
|
justify-content: space-between; |
|
|
} |
|
|
|
|
|
.stat-label { |
|
|
color: #aaa; |
|
|
} |
|
|
|
|
|
.stat-value { |
|
|
color: var(--clean-text); |
|
|
} |
|
|
|
|
|
|
|
|
.loading-screen { |
|
|
position: fixed; |
|
|
top: 0; left: 0; width: 100%; height: 100%; |
|
|
background: var(--terminal-black); |
|
|
display: flex; align-items: center; justify-content: center; |
|
|
z-index: 9999; flex-direction: column; |
|
|
font-size: 1.2rem; |
|
|
text-align: center; |
|
|
} |
|
|
|
|
|
.webxos-logo { |
|
|
font-size: 6rem; |
|
|
font-weight: bold; |
|
|
margin-bottom: 20px; |
|
|
color: var(--hf-purple); |
|
|
animation: glow 2s infinite alternate; |
|
|
} |
|
|
|
|
|
.loading-bar { |
|
|
width: 400px; height: 20px; |
|
|
background: var(--terminal-light-gray); |
|
|
margin-top: 40px; |
|
|
border-radius: 10px; |
|
|
overflow: hidden; |
|
|
border: 2px solid var(--hf-purple); |
|
|
} |
|
|
|
|
|
.loading-fill { |
|
|
width: 0%; height: 100%; |
|
|
background: var(--hf-purple); |
|
|
transition: width 0.3s; |
|
|
} |
|
|
|
|
|
|
|
|
.taskbar { |
|
|
height: 42px; |
|
|
background: var(--terminal-gray); |
|
|
border-top: 1px solid #fff; |
|
|
display: flex; |
|
|
align-items: center; |
|
|
padding: 0 6px; |
|
|
box-shadow: 0 -1px 3px rgba(0,0,0,0.5); |
|
|
z-index: 1000; |
|
|
position: fixed; |
|
|
bottom: 0; |
|
|
width: 100%; |
|
|
} |
|
|
|
|
|
.start-btn { |
|
|
background: var(--terminal-black); |
|
|
border: 1px outset var(--hf-purple); |
|
|
padding: 4px 14px; |
|
|
font-weight: bold; |
|
|
color: var(--hf-purple); |
|
|
cursor: pointer; |
|
|
margin-right: 8px; |
|
|
font-size: 1rem; |
|
|
min-height: 32px; |
|
|
} |
|
|
|
|
|
.task-icon { |
|
|
width: 32px; height: 32px; |
|
|
background: var(--terminal-light-gray); |
|
|
border: 1px solid var(--terminal-medium-gray); |
|
|
display: flex; |
|
|
align-items: center; |
|
|
justify-content: center; |
|
|
cursor: pointer; |
|
|
font-size: 1rem; |
|
|
color: var(--hf-purple); |
|
|
margin-right: 6px; |
|
|
} |
|
|
|
|
|
.task-icon.active { |
|
|
background: var(--hf-purple); |
|
|
color: black; |
|
|
} |
|
|
|
|
|
.clock { |
|
|
margin-left: auto; |
|
|
font-size: 1rem; |
|
|
padding: 0 10px; |
|
|
} |
|
|
|
|
|
|
|
|
@media (max-width: 768px) { |
|
|
.hf-container { |
|
|
flex-direction: column; |
|
|
padding: 10px; |
|
|
} |
|
|
|
|
|
.hf-window { |
|
|
width: 95%; |
|
|
height: 90%; |
|
|
} |
|
|
|
|
|
.config-panel { |
|
|
min-width: unset; |
|
|
} |
|
|
|
|
|
.webxos-logo { |
|
|
font-size: 4rem; |
|
|
} |
|
|
|
|
|
.loading-bar { |
|
|
width: 90%; |
|
|
} |
|
|
} |
|
|
|
|
|
@keyframes fadeIn { |
|
|
from { opacity: 0; transform: translateY(-5px); } |
|
|
to { opacity: 1; transform: translateY(0); } |
|
|
} |
|
|
|
|
|
@keyframes glow { |
|
|
0% { text-shadow: 0 0 10px rgba(124, 58, 237, 0.5); } |
|
|
100% { text-shadow: 0 0 20px rgba(124, 58, 237, 0.8), 0 0 30px rgba(124, 58, 237, 0.6); } |
|
|
} |
|
|
</style> |
|
|
</head> |
|
|
<body> |
|
|
|
|
|
<div class="hf-window" id="hfWindow"> |
|
|
<div class="hf-header"> |
|
|
<div class="hf-title"> |
|
|
<i class="fas fa-database"></i> |
|
|
<span>MATRIX/MA DATASETS by webXOS</span> |
|
|
</div> |
|
|
<div class="hf-controls"> |
|
|
<button class="hf-btn primary" onclick="hfGenerator.generateDataset()"> |
|
|
<i class="fas fa-play"></i> Generate Dataset |
|
|
</button> |
|
|
<button class="hf-btn" onclick="hfGenerator.exportDataset()" id="exportBtn" disabled> |
|
|
<i class="fas fa-file-export"></i> Export ZIP |
|
|
</button> |
|
|
<button class="hf-btn close" onclick="closeHFWindow()"> |
|
|
<i class="fas fa-times"></i> Close |
|
|
</button> |
|
|
</div> |
|
|
</div> |
|
|
<div class="hf-container"> |
|
|
<div class="config-panel"> |
|
|
<div class="config-header"> |
|
|
<span>DATASET CONFIGURATION</span> |
|
|
<span id="configStatus">READY</span> |
|
|
</div> |
|
|
<div class="config-content"> |
|
|
<div class="config-section"> |
|
|
<div class="section-title"> |
|
|
<i class="fas fa-sliders-h"></i> |
|
|
<span>Dataset Parameters</span> |
|
|
</div> |
|
|
<div class="config-input"> |
|
|
<label>Dataset Name</label> |
|
|
<input type="text" id="datasetName" value="matrix_operations" placeholder="Enter dataset name"> |
|
|
</div> |
|
|
<div class="config-input"> |
|
|
<label>Number of Samples</label> |
|
|
<div class="slider-container"> |
|
|
<input type="range" id="sampleCount" min="10" max="5000" value="500" step="10"> |
|
|
<span class="slider-value" id="sampleCountValue">500</span> |
|
|
</div> |
|
|
</div> |
|
|
<div class="config-input"> |
|
|
<label>Matrix Dimensions</label> |
|
|
<div class="slider-container"> |
|
|
<input type="range" id="matrixSize" min="2" max="16" value="8" step="2"> |
|
|
<span class="slider-value" id="matrixSizeValue">8×8</span> |
|
|
</div> |
|
|
</div> |
|
|
<div class="config-input"> |
|
|
<label>Data Format</label> |
|
|
<select id="dataFormat"> |
|
|
<option value="jsonl">JSON Lines (.jsonl)</option> |
|
|
<option value="csv">CSV (.csv)</option> |
|
|
<option value="json">JSON (.json)</option> |
|
|
</select> |
|
|
</div> |
|
|
<div class="config-input"> |
|
|
<label>Train/Test Split</label> |
|
|
<div class="slider-container"> |
|
|
<input type="range" id="trainSplit" min="50" max="100" value="80" step="5"> |
|
|
<span class="slider-value" id="trainSplitValue">80% Train</span> |
|
|
</div> |
|
|
</div> |
|
|
</div> |
|
|
|
|
|
<div class="config-section"> |
|
|
<div class="section-title"> |
|
|
<i class="fas fa-cogs"></i> |
|
|
<span>Operations</span> |
|
|
</div> |
|
|
<div class="checkbox-group"> |
|
|
<div class="checkbox-item"> |
|
|
<input type="checkbox" id="opMatmul" checked> |
|
|
<label for="opMatmul">Matrix Multiplication</label> |
|
|
</div> |
|
|
<div class="checkbox-item"> |
|
|
<input type="checkbox" id="opAdd" checked> |
|
|
<label for="opAdd">Matrix Addition</label> |
|
|
</div> |
|
|
<div class="checkbox-item"> |
|
|
<input type="checkbox" id="opTranspose"> |
|
|
<label for="opTranspose">Matrix Transpose</label> |
|
|
</div> |
|
|
<div class="checkbox-item"> |
|
|
<input type="checkbox" id="opInverse"> |
|
|
<label for="opInverse">Matrix Inverse</label> |
|
|
</div> |
|
|
</div> |
|
|
</div> |
|
|
|
|
|
<div class="config-section"> |
|
|
<div class="section-title"> |
|
|
<i class="fas fa-file-alt"></i> |
|
|
<span>Metadata</span> |
|
|
</div> |
|
|
<div class="config-input"> |
|
|
<label>Description</label> |
|
|
<input type="text" id="datasetDesc" value="Synthetic matrix operations dataset for ML training" placeholder="Dataset description"> |
|
|
</div> |
|
|
<div class="config-input"> |
|
|
<label>License</label> |
|
|
<select id="datasetLicense"> |
|
|
<option value="apache-2.0">Apache 2.0</option> |
|
|
<option value="mit">MIT</option> |
|
|
<option value="cc-by-4.0">CC-BY-4.0</option> |
|
|
<option value="cc-by-sa-4.0">CC-BY-SA-4.0</option> |
|
|
</select> |
|
|
</div> |
|
|
</div> |
|
|
|
|
|
<div class="progress-container"> |
|
|
<div class="progress-header"> |
|
|
<span>Generation Progress</span> |
|
|
<span id="progressPercent">0%</span> |
|
|
</div> |
|
|
<div class="progress-bar"> |
|
|
<div class="progress-fill" id="progressFill"></div> |
|
|
</div> |
|
|
<div class="progress-stats"> |
|
|
<div class="stat-item"> |
|
|
<span class="stat-label">Samples:</span> |
|
|
<span class="stat-value" id="statSamples">0/500</span> |
|
|
</div> |
|
|
<div class="stat-item"> |
|
|
<span class="stat-label">Size:</span> |
|
|
<span class="stat-value" id="statSize">0 KB</span> |
|
|
</div> |
|
|
<div class="stat-item"> |
|
|
<span class="stat-label">Time:</span> |
|
|
<span class="stat-value" id="statTime">0s</span> |
|
|
</div> |
|
|
<div class="stat-item"> |
|
|
<span class="stat-label">Format:</span> |
|
|
<span class="stat-value" id="statFormat">jsonl</span> |
|
|
</div> |
|
|
</div> |
|
|
</div> |
|
|
</div> |
|
|
</div> |
|
|
|
|
|
<div class="terminal-panel"> |
|
|
<div class="terminal-header"> |
|
|
<span>GENERATION TERMINAL</span> |
|
|
<span id="terminalStatus">READY</span> |
|
|
</div> |
|
|
<div class="terminal-output" id="terminalOutput"> |
|
|
<div class="terminal-line hf">⟩⟩ MATRIXMA DATASETS Dataset Generator v2.2</div> |
|
|
<div class="terminal-line output">Fixed Hugging Face schema compatibility</div> |
|
|
<div class="terminal-line output">All exports validated for HF Hub upload</div> |
|
|
<div class="terminal-line output">Configure parameters and click "Generate Dataset"</div> |
|
|
</div> |
|
|
<div class="terminal-input"> |
|
|
<div class="input-prompt">⟩⟩</div> |
|
|
<input type="text" id="hfInput" placeholder="Enter command (help for options)..." autocomplete="off"> |
|
|
<button class="hf-btn" onclick="hfGenerator.executeCommand()">Execute</button> |
|
|
</div> |
|
|
</div> |
|
|
</div> |
|
|
</div> |
|
|
|
|
|
|
|
|
<div class="loading-screen" id="loadingScreen"> |
|
|
<div class="webxos-logo">MATRIX/MA DATASETS</div> |
|
|
<div>v2.2 - by webXOS 2026</div> |
|
|
<div class="loading-bar"><div class="loading-fill" id="loadingFill"></div></div> |
|
|
</div> |
|
|
|
|
|
|
|
|
<div class="taskbar" id="taskbar" style="display: none;"> |
|
|
<button class="start-btn" onclick="openHFWindow()">MATRIX MULTIPLIER DATASET GEN</button> |
|
|
<div class="task-icon" onclick="openHFWindow()"> |
|
|
<i class="fas fa-database"></i> |
|
|
</div> |
|
|
<div class="clock" id="clock">00:00:00</div> |
|
|
</div> |
|
|
|
|
|
<script> |
|
|
|
|
|
class HFDatasetGenerator { |
|
|
constructor() { |
|
|
this.tfReady = false; |
|
|
this.isGenerating = false; |
|
|
this.dataset = { train: [], test: [] }; |
|
|
this.metadata = { |
|
|
name: "matrix_operations", |
|
|
description: "Synthetic matrix operations dataset", |
|
|
license: "apache-2.0", |
|
|
format: "jsonl", |
|
|
generated_at: null, |
|
|
splits: { train: 0, test: 0 } |
|
|
}; |
|
|
this.stats = { |
|
|
samples: 0, |
|
|
totalSamples: 500, |
|
|
startTime: 0, |
|
|
sizeKB: 0, |
|
|
backend: 'unknown' |
|
|
}; |
|
|
|
|
|
this.init(); |
|
|
this.setupConfigListeners(); |
|
|
} |
|
|
|
|
|
async init() { |
|
|
this.printTerminal("Initializing HF Dataset Generator v2.2 (HF Schema Fixed)...", "hf"); |
|
|
this.printTerminal("Fixed schema compatibility for Hugging Face Hub", "success"); |
|
|
|
|
|
try { |
|
|
|
|
|
try { |
|
|
await tf.setBackend('webgl'); |
|
|
await tf.ready(); |
|
|
this.stats.backend = 'webgl'; |
|
|
this.printTerminal(`✓ TensorFlow.js backend: WebGL (GPU)`, "success"); |
|
|
} catch (webglError) { |
|
|
this.printTerminal(`WebGL failed: ${webglError.message}`, "warning"); |
|
|
this.printTerminal("Falling back to CPU backend...", "warning"); |
|
|
await tf.setBackend('cpu'); |
|
|
await tf.ready(); |
|
|
this.stats.backend = 'cpu'; |
|
|
this.printTerminal(`✓ TensorFlow.js backend: CPU`, "info"); |
|
|
} |
|
|
|
|
|
this.tfReady = true; |
|
|
this.printTerminal("System ready for Hugging Face compatible dataset generation", "success"); |
|
|
this.updateStatus("IDLE"); |
|
|
|
|
|
} catch (error) { |
|
|
this.printTerminal(`Initialization error: ${error.message}`, "error"); |
|
|
} |
|
|
} |
|
|
|
|
|
setupConfigListeners() { |
|
|
|
|
|
document.getElementById('sampleCount').addEventListener('input', (e) => { |
|
|
const value = e.target.value; |
|
|
document.getElementById('sampleCountValue').textContent = value; |
|
|
this.stats.totalSamples = parseInt(value); |
|
|
document.getElementById('statSamples').textContent = `0/${value}`; |
|
|
}); |
|
|
|
|
|
document.getElementById('matrixSize').addEventListener('input', (e) => { |
|
|
const size = e.target.value; |
|
|
document.getElementById('matrixSizeValue').textContent = `${size}×${size}`; |
|
|
}); |
|
|
|
|
|
document.getElementById('trainSplit').addEventListener('input', (e) => { |
|
|
const value = e.target.value; |
|
|
document.getElementById('trainSplitValue').textContent = `${value}% Train`; |
|
|
}); |
|
|
|
|
|
|
|
|
document.getElementById('dataFormat').addEventListener('change', (e) => { |
|
|
const format = e.target.value; |
|
|
document.getElementById('statFormat').textContent = format; |
|
|
}); |
|
|
} |
|
|
|
|
|
async generateDataset() { |
|
|
if (this.isGenerating) { |
|
|
this.printTerminal("Dataset generation already in progress", "warning"); |
|
|
return; |
|
|
} |
|
|
|
|
|
this.isGenerating = true; |
|
|
this.dataset = { train: [], test: [] }; |
|
|
this.updateStatus("GENERATING"); |
|
|
|
|
|
|
|
|
const config = this.getConfig(); |
|
|
const trainSplit = config.trainSplit; |
|
|
const trainCount = Math.floor(config.sampleCount * (trainSplit / 100)); |
|
|
const testCount = config.sampleCount - trainCount; |
|
|
|
|
|
this.metadata = { |
|
|
name: config.name, |
|
|
description: config.description, |
|
|
license: config.license, |
|
|
format: config.format, |
|
|
generated_at: new Date().toISOString(), |
|
|
operations: config.operations, |
|
|
matrix_size: config.matrixSize, |
|
|
backend: this.stats.backend, |
|
|
splits: { train: trainCount, test: testCount } |
|
|
}; |
|
|
|
|
|
this.stats = { |
|
|
samples: 0, |
|
|
totalSamples: config.sampleCount, |
|
|
startTime: performance.now(), |
|
|
sizeKB: 0, |
|
|
backend: this.stats.backend |
|
|
}; |
|
|
|
|
|
this.printTerminal(`Starting dataset generation: ${config.name}`, "hf"); |
|
|
this.printTerminal(`Backend: ${this.stats.backend.toUpperCase()}`, "info"); |
|
|
this.printTerminal(`Samples: ${config.sampleCount} (Train: ${trainCount}, Test: ${testCount})`, "info"); |
|
|
this.printTerminal(`Matrix: ${config.matrixSize}×${config.matrixSize}`, "info"); |
|
|
this.printTerminal(`Operations: ${config.operations.join(', ')}`, "info"); |
|
|
this.printTerminal(`Format: ${config.format}`, "info"); |
|
|
|
|
|
|
|
|
this.updateProgress(0); |
|
|
document.getElementById('exportBtn').disabled = true; |
|
|
|
|
|
|
|
|
for (let i = 0; i < config.sampleCount; i++) { |
|
|
if (!this.isGenerating) break; |
|
|
|
|
|
const sample = await this.generateSample(config.matrixSize, config.operations); |
|
|
|
|
|
|
|
|
if (i < trainCount) { |
|
|
this.dataset.train.push(sample); |
|
|
} else { |
|
|
this.dataset.test.push(sample); |
|
|
} |
|
|
|
|
|
this.stats.samples = i + 1; |
|
|
|
|
|
|
|
|
if ((i + 1) % 10 === 0 || i === config.sampleCount - 1) { |
|
|
const progress = ((i + 1) / config.sampleCount) * 100; |
|
|
this.updateProgress(progress); |
|
|
|
|
|
|
|
|
const elapsed = (performance.now() - this.stats.startTime) / 1000; |
|
|
const size = this.calculateSize(); |
|
|
document.getElementById('statTime').textContent = `${elapsed.toFixed(1)}s`; |
|
|
document.getElementById('statSize').textContent = `${size} KB`; |
|
|
document.getElementById('statSamples').textContent = `${i + 1}/${config.sampleCount}`; |
|
|
|
|
|
if ((i + 1) % 100 === 0) { |
|
|
this.printTerminal(`Generated ${i + 1}/${config.sampleCount} samples`, "output"); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
if (i % 20 === 0) await new Promise(resolve => setTimeout(resolve, 0)); |
|
|
} |
|
|
|
|
|
if (this.isGenerating) { |
|
|
const elapsed = ((performance.now() - this.stats.startTime) / 1000).toFixed(2); |
|
|
const size = this.calculateSize(); |
|
|
|
|
|
this.printTerminal(`Dataset generation complete!`, "success"); |
|
|
this.printTerminal(`✓ ${config.sampleCount} samples in ${elapsed}s`, "success"); |
|
|
this.printTerminal(`✓ ${trainCount} train samples, ${testCount} test samples`, "success"); |
|
|
this.printTerminal(`✓ Total size: ${size} KB`, "success"); |
|
|
this.printTerminal(`✓ Ready for Hugging Face Hub upload`, "success"); |
|
|
|
|
|
this.updateStatus("COMPLETE"); |
|
|
document.getElementById('exportBtn').disabled = false; |
|
|
this.showDatasetSummary(); |
|
|
} |
|
|
|
|
|
this.isGenerating = false; |
|
|
} |
|
|
|
|
|
async generateSample(matrixSize, operations) { |
|
|
const sampleId = `sample_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`; |
|
|
const sample = { |
|
|
id: sampleId, |
|
|
timestamp: new Date().toISOString(), |
|
|
matrix_size: matrixSize, |
|
|
operations: [] |
|
|
}; |
|
|
|
|
|
|
|
|
const matrixA = tf.randomNormal([matrixSize, matrixSize], 0, 1); |
|
|
const matrixB = tf.randomNormal([matrixSize, matrixSize], 0, 1); |
|
|
|
|
|
|
|
|
for (const op of operations) { |
|
|
let result, time, operationData = { type: op }; |
|
|
|
|
|
try { |
|
|
const start = performance.now(); |
|
|
|
|
|
switch(op) { |
|
|
case 'matmul': |
|
|
result = tf.matMul(matrixA, matrixB); |
|
|
await result.data(); |
|
|
time = performance.now() - start; |
|
|
operationData.time_ms = time; |
|
|
operationData.matrix_a = Array.from(matrixA.dataSync()); |
|
|
operationData.matrix_b = Array.from(matrixB.dataSync()); |
|
|
operationData.result = Array.from(result.dataSync()); |
|
|
result.dispose(); |
|
|
break; |
|
|
|
|
|
case 'add': |
|
|
result = tf.add(matrixA, matrixB); |
|
|
await result.data(); |
|
|
time = performance.now() - start; |
|
|
operationData.time_ms = time; |
|
|
operationData.matrix_a = Array.from(matrixA.dataSync()); |
|
|
operationData.matrix_b = Array.from(matrixB.dataSync()); |
|
|
operationData.result = Array.from(result.dataSync()); |
|
|
result.dispose(); |
|
|
break; |
|
|
|
|
|
case 'transpose': |
|
|
result = tf.transpose(matrixA); |
|
|
await result.data(); |
|
|
time = performance.now() - start; |
|
|
operationData.time_ms = time; |
|
|
operationData.matrix = Array.from(matrixA.dataSync()); |
|
|
operationData.result = Array.from(result.dataSync()); |
|
|
result.dispose(); |
|
|
break; |
|
|
|
|
|
case 'inverse': |
|
|
|
|
|
const identity = tf.eye(matrixSize); |
|
|
const perturbation = tf.randomNormal([matrixSize, matrixSize], 0, 0.1); |
|
|
const invertibleMatrix = tf.add(identity, perturbation); |
|
|
|
|
|
try { |
|
|
result = tf.linalg.inv(invertibleMatrix); |
|
|
await result.data(); |
|
|
time = performance.now() - start; |
|
|
operationData.time_ms = time; |
|
|
operationData.matrix = Array.from(invertibleMatrix.dataSync()); |
|
|
operationData.result = Array.from(result.dataSync()); |
|
|
result.dispose(); |
|
|
} catch (invError) { |
|
|
operationData.time_ms = time; |
|
|
operationData.matrix = Array.from(invertibleMatrix.dataSync()); |
|
|
operationData.result = []; |
|
|
operationData.error = "Matrix not invertible"; |
|
|
} |
|
|
|
|
|
identity.dispose(); |
|
|
perturbation.dispose(); |
|
|
invertibleMatrix.dispose(); |
|
|
break; |
|
|
} |
|
|
|
|
|
sample.operations.push(operationData); |
|
|
|
|
|
} catch (error) { |
|
|
this.printTerminal(`Error in operation ${op}: ${error.message}`, "error"); |
|
|
operationData.error = error.message; |
|
|
sample.operations.push(operationData); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
matrixA.dispose(); |
|
|
matrixB.dispose(); |
|
|
|
|
|
return sample; |
|
|
} |
|
|
|
|
|
getConfig() { |
|
|
const selectedOps = []; |
|
|
|
|
|
if (document.getElementById('opMatmul').checked) selectedOps.push('matmul'); |
|
|
if (document.getElementById('opAdd').checked) selectedOps.push('add'); |
|
|
if (document.getElementById('opTranspose').checked) selectedOps.push('transpose'); |
|
|
if (document.getElementById('opInverse').checked) selectedOps.push('inverse'); |
|
|
|
|
|
return { |
|
|
name: document.getElementById('datasetName').value, |
|
|
sampleCount: parseInt(document.getElementById('sampleCount').value), |
|
|
matrixSize: parseInt(document.getElementById('matrixSize').value), |
|
|
format: document.getElementById('dataFormat').value, |
|
|
description: document.getElementById('datasetDesc').value, |
|
|
license: document.getElementById('datasetLicense').value, |
|
|
trainSplit: parseInt(document.getElementById('trainSplit').value), |
|
|
operations: selectedOps |
|
|
}; |
|
|
} |
|
|
|
|
|
calculateSize() { |
|
|
const allData = [...this.dataset.train, ...this.dataset.test]; |
|
|
const jsonString = JSON.stringify(allData); |
|
|
return (new TextEncoder().encode(jsonString).length / 1024).toFixed(2); |
|
|
} |
|
|
|
|
|
async exportDataset() { |
|
|
if (this.dataset.train.length === 0 && this.dataset.test.length === 0) { |
|
|
this.printTerminal("No dataset to export. Generate a dataset first.", "warning"); |
|
|
return; |
|
|
} |
|
|
|
|
|
this.printTerminal("Preparing dataset for Hugging Face export...", "hf"); |
|
|
this.updateStatus("EXPORTING"); |
|
|
|
|
|
const config = this.getConfig(); |
|
|
const zip = new JSZip(); |
|
|
|
|
|
|
|
|
const datasetFolder = zip.folder(config.name); |
|
|
|
|
|
|
|
|
switch(config.format) { |
|
|
case 'jsonl': |
|
|
if (this.dataset.train.length > 0) { |
|
|
const trainJsonl = this.dataset.train.map(s => JSON.stringify(s)).join('\n'); |
|
|
datasetFolder.file("train.jsonl", trainJsonl); |
|
|
} |
|
|
if (this.dataset.test.length > 0) { |
|
|
const testJsonl = this.dataset.test.map(s => JSON.stringify(s)).join('\n'); |
|
|
datasetFolder.file("test.jsonl", testJsonl); |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'json': |
|
|
if (this.dataset.train.length > 0) { |
|
|
datasetFolder.file("train.json", JSON.stringify(this.dataset.train, null, 2)); |
|
|
} |
|
|
if (this.dataset.test.length > 0) { |
|
|
datasetFolder.file("test.json", JSON.stringify(this.dataset.test, null, 2)); |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'csv': |
|
|
|
|
|
if (this.dataset.train.length > 0) { |
|
|
const trainCsv = this.convertToCSV(this.dataset.train); |
|
|
datasetFolder.file("train.csv", trainCsv); |
|
|
} |
|
|
if (this.dataset.test.length > 0) { |
|
|
const testCsv = this.convertToCSV(this.dataset.test); |
|
|
datasetFolder.file("test.csv", testCsv); |
|
|
} |
|
|
break; |
|
|
} |
|
|
|
|
|
|
|
|
const readmeContent = this.generateReadme(); |
|
|
datasetFolder.file("README.md", readmeContent); |
|
|
|
|
|
const datasetCard = this.generateDatasetCard(); |
|
|
datasetFolder.file("dataset_card.md", datasetCard); |
|
|
|
|
|
const metadata = { |
|
|
...this.metadata, |
|
|
samples: this.dataset.train.length + this.dataset.test.length, |
|
|
train_samples: this.dataset.train.length, |
|
|
test_samples: this.dataset.test.length, |
|
|
size_kb: this.calculateSize() |
|
|
}; |
|
|
datasetFolder.file("metadata.json", JSON.stringify(metadata, null, 2)); |
|
|
|
|
|
|
|
|
const loadScript = this.generateLoadScript(config); |
|
|
datasetFolder.file("load_dataset.py", loadScript); |
|
|
|
|
|
|
|
|
try { |
|
|
const content = await zip.generateAsync({ type: "blob" }); |
|
|
const filename = `${config.name}_hf_dataset.zip`; |
|
|
|
|
|
const a = document.createElement("a"); |
|
|
const url = URL.createObjectURL(content); |
|
|
a.href = url; |
|
|
a.download = filename; |
|
|
document.body.appendChild(a); |
|
|
a.click(); |
|
|
document.body.removeChild(a); |
|
|
URL.revokeObjectURL(url); |
|
|
|
|
|
this.printTerminal(`✓ Dataset exported as ${filename}`, "success"); |
|
|
this.printTerminal("Ready for Hugging Face Hub upload:", "hf"); |
|
|
this.printTerminal(" cd " + config.name, "output"); |
|
|
this.printTerminal(" git init", "output"); |
|
|
this.printTerminal(" git lfs install", "output"); |
|
|
this.printTerminal(" git add .", "output"); |
|
|
this.printTerminal(' git commit -m "Add dataset"', "output"); |
|
|
this.printTerminal(` git push https://huggingface.co/datasets/your-username/${config.name}`, "output"); |
|
|
|
|
|
this.updateStatus("EXPORTED"); |
|
|
|
|
|
} catch (error) { |
|
|
this.printTerminal(`Export error: ${error.message}`, "error"); |
|
|
this.updateStatus("ERROR"); |
|
|
} |
|
|
} |
|
|
|
|
|
convertToCSV(samples) { |
|
|
|
|
|
const rows = []; |
|
|
|
|
|
|
|
|
const headers = ['id', 'timestamp', 'matrix_size', 'operations_count']; |
|
|
rows.push(headers.join(',')); |
|
|
|
|
|
|
|
|
for (const sample of samples) { |
|
|
const row = [ |
|
|
`"${sample.id}"`, |
|
|
`"${sample.timestamp}"`, |
|
|
sample.matrix_size, |
|
|
sample.operations.length |
|
|
]; |
|
|
rows.push(row.join(',')); |
|
|
} |
|
|
|
|
|
return rows.join('\n'); |
|
|
} |
|
|
|
|
|
generateReadme() { |
|
|
const config = this.getConfig(); |
|
|
const totalSamples = this.dataset.train.length + this.dataset.test.length; |
|
|
const totalBytes = this.calculateSize() * 1024; |
|
|
|
|
|
|
|
|
return `--- |
|
|
language: |
|
|
- en |
|
|
task_categories: |
|
|
- matrix-computation |
|
|
- synthetic-data-generation |
|
|
tags: |
|
|
- matrix-operations |
|
|
- synthetic-data |
|
|
- machine-learning |
|
|
- mathematics |
|
|
license: ${config.license} |
|
|
dataset_info: |
|
|
features: |
|
|
- name: id |
|
|
dtype: string |
|
|
- name: timestamp |
|
|
dtype: string |
|
|
- name: matrix_size |
|
|
dtype: int32 |
|
|
- name: operations |
|
|
list: |
|
|
- name: type |
|
|
dtype: string |
|
|
- name: time_ms |
|
|
dtype: float32 |
|
|
- name: matrix_a |
|
|
sequence: float32 |
|
|
- name: matrix_b |
|
|
sequence: float32 |
|
|
- name: matrix |
|
|
sequence: float32 |
|
|
- name: result |
|
|
sequence: float32 |
|
|
- name: error |
|
|
dtype: string |
|
|
splits: |
|
|
- name: train |
|
|
num_bytes: ${Math.round(totalBytes * (this.dataset.train.length / totalSamples))} |
|
|
num_examples: ${this.dataset.train.length} |
|
|
- name: test |
|
|
num_bytes: ${Math.round(totalBytes * (this.dataset.test.length / totalSamples))} |
|
|
num_examples: ${this.dataset.test.length} |
|
|
download_size: ${Math.round(totalBytes)} |
|
|
dataset_size: ${Math.round(totalBytes)} |
|
|
pretty_name: "${config.name}" |
|
|
size_categories: |
|
|
- ${totalSamples < 1000 ? 'n<1K' : totalSamples < 10000 ? '1K<n<10K' : '10K<n<100K'} |
|
|
--- |
|
|
|
|
|
# ${config.name} |
|
|
|
|
|
${config.description} |
|
|
|
|
|
## Dataset Details |
|
|
|
|
|
- **Generated:** ${new Date().toISOString()} |
|
|
- **Total Samples:** ${totalSamples} |
|
|
- **Splits:** Train (${this.dataset.train.length}), Test (${this.dataset.test.length}) |
|
|
- **Matrix Size:** ${config.matrixSize}×${config.matrixSize} |
|
|
- **Operations:** ${config.operations.join(', ') || 'None selected'} |
|
|
- **Backend:** ${this.stats.backend.toUpperCase()} |
|
|
- **Format:** ${config.format} |
|
|
|
|
|
## Usage |
|
|
|
|
|
\`\`\`python |
|
|
from datasets import load_dataset |
|
|
|
|
|
# Load the dataset |
|
|
dataset = load_dataset("${config.name}") |
|
|
|
|
|
# Access train and test splits |
|
|
train_dataset = dataset["train"] |
|
|
test_dataset = dataset["test"] |
|
|
\`\`\` |
|
|
|
|
|
## Example |
|
|
|
|
|
\`\`\`python |
|
|
import datasets |
|
|
|
|
|
# Load dataset |
|
|
ds = datasets.load_dataset("${config.name}") |
|
|
|
|
|
# Get first example |
|
|
example = ds["train"][0] |
|
|
print(f"ID: {example['id']}") |
|
|
print(f"Matrix Size: {example['matrix_size']}") |
|
|
print(f"Operations: {len(example['operations'])}") |
|
|
\`\`\` |
|
|
|
|
|
## Citation |
|
|
|
|
|
If you use this dataset in research, please cite: |
|
|
|
|
|
\`\`\`bibtex |
|
|
@dataset{${config.name.replace(/[^a-z0-9]/gi, '_').toLowerCase()}_${new Date().getFullYear()}, |
|
|
title = {${config.name}}, |
|
|
author = {Generated by HF Dataset Generator v2.2}, |
|
|
year = {${new Date().getFullYear()}}, |
|
|
publisher = {Hugging Face}, |
|
|
url = {https://huggingface.co/datasets/your-username/${config.name}} |
|
|
} |
|
|
\`\`\` |
|
|
|
|
|
## License |
|
|
|
|
|
${config.license} |
|
|
`; |
|
|
} |
|
|
|
|
|
generateDatasetCard() { |
|
|
const config = this.getConfig(); |
|
|
const totalSamples = this.dataset.train.length + this.dataset.test.length; |
|
|
|
|
|
return `# Dataset Card for ${config.name} |
|
|
|
|
|
## Dataset Description |
|
|
|
|
|
- **Homepage:** [Add homepage URL if available] |
|
|
- **Repository:** [Add repository URL] |
|
|
- **Point of Contact:** [Add contact name/email] |
|
|
|
|
|
### Dataset Summary |
|
|
|
|
|
${config.description} |
|
|
|
|
|
This dataset was automatically generated using the HF Dataset Generator v2.2 with TensorFlow.js backend (${this.stats.backend}). |
|
|
|
|
|
### Supported Tasks |
|
|
|
|
|
- Matrix operation prediction |
|
|
- Computational performance benchmarking |
|
|
- Synthetic data for ML training |
|
|
- Algorithm validation and testing |
|
|
|
|
|
### Languages |
|
|
|
|
|
English |
|
|
|
|
|
## Dataset Structure |
|
|
|
|
|
### Data Instances |
|
|
|
|
|
Each instance contains: |
|
|
- Unique sample ID |
|
|
- Generation timestamp |
|
|
- Matrix size (n×n) |
|
|
- List of operations performed with: |
|
|
- Operation type |
|
|
- Execution time in milliseconds |
|
|
- Input matrices |
|
|
- Result matrices |
|
|
- Error messages (if any) |
|
|
|
|
|
### Data Fields |
|
|
|
|
|
- \`id\`: Unique identifier (string) |
|
|
- \`timestamp\`: Generation timestamp (string) |
|
|
- \`matrix_size\`: Dimension of matrices (int32) |
|
|
- \`operations\`: List of operations performed (list of dicts) |
|
|
|
|
|
### Data Splits |
|
|
|
|
|
- **Train:** ${this.dataset.train.length} samples |
|
|
- **Test:** ${this.dataset.test.length} samples |
|
|
|
|
|
## Dataset Creation |
|
|
|
|
|
### Curation Rationale |
|
|
|
|
|
This dataset was created to provide synthetic matrix operation data for machine learning research, benchmarking computational kernels, and testing numerical algorithms. |
|
|
|
|
|
### Source Data |
|
|
|
|
|
Synthetically generated using TensorFlow.js matrix operations with random normal distributions. |
|
|
|
|
|
### Annotations |
|
|
|
|
|
No human annotations. |
|
|
|
|
|
### Personal and Sensitive Information |
|
|
|
|
|
None. All data is synthetically generated. |
|
|
|
|
|
## Considerations for Using the Data |
|
|
|
|
|
### Social Impact |
|
|
|
|
|
This dataset enables research in computational mathematics, machine learning optimization, and numerical analysis education. |
|
|
|
|
|
### Discussion of Biases |
|
|
|
|
|
Matrices are randomly generated from normal distributions (mean=0, std=1). Real-world matrices may have different distributions. |
|
|
|
|
|
### Other Known Limitations |
|
|
|
|
|
1. Matrix inverse may fail for singular matrices |
|
|
2. Performance timing varies by hardware (${this.stats.backend} backend) |
|
|
3. Limited to square matrices |
|
|
|
|
|
## Additional Information |
|
|
|
|
|
### Dataset Curators |
|
|
|
|
|
Generated automatically by HF Dataset Generator v2.2 |
|
|
|
|
|
### Licensing Information |
|
|
|
|
|
${config.license} License |
|
|
|
|
|
### Contributions |
|
|
|
|
|
Thanks to TensorFlow.js and Hugging Face communities. |
|
|
`; |
|
|
} |
|
|
|
|
|
generateLoadScript(config) { |
|
|
return `#!/usr/bin/env python3 |
|
|
""" |
|
|
Script to load and verify the ${config.name} dataset |
|
|
""" |
|
|
|
|
|
import json |
|
|
from pathlib import Path |
|
|
|
|
|
def load_and_verify_dataset(): |
|
|
dataset_path = Path(".") |
|
|
|
|
|
print(f"Loading {config.name} dataset...") |
|
|
|
|
|
# Load train split |
|
|
train_data = [] |
|
|
if (dataset_path / "train.jsonl").exists(): |
|
|
with open(dataset_path / "train.jsonl", "r") as f: |
|
|
for line in f: |
|
|
train_data.append(json.loads(line)) |
|
|
print(f"Loaded {len(train_data)} train samples") |
|
|
|
|
|
# Load test split |
|
|
test_data = [] |
|
|
if (dataset_path / "test.jsonl").exists(): |
|
|
with open(dataset_path / "test.jsonl", "r") as f: |
|
|
for line in f: |
|
|
test_data.append(json.loads(line)) |
|
|
print(f"Loaded {len(test_data)} test samples") |
|
|
|
|
|
# Basic validation |
|
|
print("\\nDataset Validation:") |
|
|
print(f"Total samples: {len(train_data) + len(test_data)}") |
|
|
|
|
|
if train_data: |
|
|
sample = train_data[0] |
|
|
print(f"Sample keys: {list(sample.keys())}") |
|
|
print(f"Matrix size: {sample.get('matrix_size')}") |
|
|
print(f"Operations count: {len(sample.get('operations', []))}") |
|
|
|
|
|
print("\\nDataset ready for use!") |
|
|
print("To upload to Hugging Face Hub:") |
|
|
print(f" git push https://huggingface.co/datasets/your-username/{config.name}") |
|
|
|
|
|
if __name__ == "__main__": |
|
|
load_and_verify_dataset() |
|
|
`; |
|
|
} |
|
|
|
|
|
showDatasetSummary() { |
|
|
const config = this.getConfig(); |
|
|
const size = this.calculateSize(); |
|
|
const elapsed = ((performance.now() - this.stats.startTime) / 1000).toFixed(2); |
|
|
const totalSamples = this.dataset.train.length + this.dataset.test.length; |
|
|
|
|
|
let summary = ` |
|
|
=== DATASET SUMMARY === |
|
|
|
|
|
Name: ${config.name} |
|
|
Description: ${config.description} |
|
|
Total Samples: ${totalSamples} |
|
|
Train/Test: ${this.dataset.train.length}/${this.dataset.test.length} |
|
|
Matrix Size: ${config.matrixSize}×${config.matrixSize} |
|
|
Operations: ${config.operations.join(', ') || 'None'} |
|
|
Format: ${config.format} |
|
|
Backend: ${this.stats.backend.toUpperCase()} |
|
|
Size: ${size} KB |
|
|
Generation Time: ${elapsed}s |
|
|
License: ${config.license} |
|
|
|
|
|
✓ Hugging Face compatible schema |
|
|
✓ Ready for HF Hub upload |
|
|
✓ Includes train/test splits |
|
|
✓ Validated YAML structure |
|
|
`.trim(); |
|
|
|
|
|
this.printTerminal(summary, "success"); |
|
|
} |
|
|
|
|
|
|
|
|
printTerminal(message, type = "output") { |
|
|
const output = document.getElementById('terminalOutput'); |
|
|
const line = document.createElement('div'); |
|
|
line.className = `terminal-line ${type}`; |
|
|
line.textContent = message; |
|
|
output.appendChild(line); |
|
|
output.scrollTop = output.scrollHeight; |
|
|
|
|
|
|
|
|
const lines = output.querySelectorAll('.terminal-line'); |
|
|
if (lines.length > 300) { |
|
|
for (let i = 0; i < 100; i++) { |
|
|
if (lines[i]) lines[i].remove(); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
updateStatus(text) { |
|
|
document.getElementById('terminalStatus').textContent = text; |
|
|
document.getElementById('configStatus').textContent = text; |
|
|
} |
|
|
|
|
|
updateProgress(percent) { |
|
|
document.getElementById('progressFill').style.width = `${percent}%`; |
|
|
document.getElementById('progressPercent').textContent = `${Math.round(percent)}%`; |
|
|
} |
|
|
|
|
|
executeCommand() { |
|
|
const input = document.getElementById('hfInput'); |
|
|
const command = input.value.trim().toLowerCase(); |
|
|
|
|
|
if (!command) return; |
|
|
|
|
|
this.printTerminal(`⟩⟩ ${command}`, "command"); |
|
|
|
|
|
switch(command) { |
|
|
case 'generate': |
|
|
case 'gen': |
|
|
this.generateDataset(); |
|
|
break; |
|
|
case 'export': |
|
|
case 'zip': |
|
|
this.exportDataset(); |
|
|
break; |
|
|
case 'clear': |
|
|
this.clearTerminal(); |
|
|
break; |
|
|
case 'help': |
|
|
this.showHelp(); |
|
|
break; |
|
|
case 'status': |
|
|
this.showStatus(); |
|
|
break; |
|
|
case 'stop': |
|
|
this.stopGeneration(); |
|
|
break; |
|
|
case 'schema': |
|
|
this.printTerminal("Using correct Hugging Face YAML schema with 'list' and 'sequence' types", "info"); |
|
|
break; |
|
|
default: |
|
|
this.printTerminal(`Unknown command: ${command}`, "error"); |
|
|
this.printTerminal("Type 'help' for available commands", "info"); |
|
|
} |
|
|
|
|
|
input.value = ''; |
|
|
input.focus(); |
|
|
} |
|
|
|
|
|
showHelp() { |
|
|
const help = ` |
|
|
Available Commands: |
|
|
------------------- |
|
|
generate / gen - Generate dataset with current configuration |
|
|
export / zip - Export dataset as ZIP (HF compatible) |
|
|
stop - Stop dataset generation |
|
|
status - Show generation status |
|
|
schema - Show schema information |
|
|
clear - Clear terminal |
|
|
help - Show this help message |
|
|
`.trim(); |
|
|
|
|
|
help.split('\n').forEach(line => { |
|
|
this.printTerminal(line, "output"); |
|
|
}); |
|
|
} |
|
|
|
|
|
showStatus() { |
|
|
let status = `Generation Status: ${this.isGenerating ? 'RUNNING' : 'IDLE'}\n`; |
|
|
status += `TensorFlow Backend: ${this.stats.backend.toUpperCase()}\n`; |
|
|
status += `Samples Generated: ${this.dataset.train.length + this.dataset.test.length}\n`; |
|
|
status += `Train Samples: ${this.dataset.train.length}\n`; |
|
|
status += `Test Samples: ${this.dataset.test.length}\n`; |
|
|
|
|
|
if (this.dataset.train.length > 0) { |
|
|
const config = this.getConfig(); |
|
|
status += `\nCurrent Configuration:\n`; |
|
|
status += `- Name: ${config.name}\n`; |
|
|
status += `- Matrix Size: ${config.matrixSize}×${config.matrixSize}\n`; |
|
|
status += `- Format: ${config.format}\n`; |
|
|
status += `- Operations: ${config.operations.join(', ') || 'None'}\n`; |
|
|
status += `- Train Split: ${config.trainSplit}%\n`; |
|
|
} |
|
|
|
|
|
this.printTerminal(status, "output"); |
|
|
} |
|
|
|
|
|
stopGeneration() { |
|
|
if (this.isGenerating) { |
|
|
this.isGenerating = false; |
|
|
this.printTerminal("Dataset generation stopped by user", "warning"); |
|
|
this.updateStatus("STOPPED"); |
|
|
} else { |
|
|
this.printTerminal("No generation in progress", "info"); |
|
|
} |
|
|
} |
|
|
|
|
|
clearTerminal() { |
|
|
document.getElementById('terminalOutput').innerHTML = ` |
|
|
<div class="terminal-line hf">⟩⟩ Hugging Face Dataset Generator v2.2</div> |
|
|
<div class="terminal-line output">Fixed Hugging Face schema compatibility</div> |
|
|
<div class="terminal-line output">All exports validated for HF Hub upload</div> |
|
|
<div class="terminal-line output">Terminal cleared</div> |
|
|
`; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
let hfGenerator = null; |
|
|
|
|
|
function openHFWindow() { |
|
|
document.getElementById('hfWindow').classList.add('active'); |
|
|
if (!hfGenerator) { |
|
|
hfGenerator = new HFDatasetGenerator(); |
|
|
} |
|
|
} |
|
|
|
|
|
function closeHFWindow() { |
|
|
document.getElementById('hfWindow').classList.remove('active'); |
|
|
} |
|
|
|
|
|
document.addEventListener('DOMContentLoaded', function() { |
|
|
|
|
|
const loadingFill = document.getElementById('loadingFill'); |
|
|
const loadingScreen = document.getElementById('loadingScreen'); |
|
|
const taskbar = document.getElementById('taskbar'); |
|
|
|
|
|
let loadProgress = 0; |
|
|
const loadInterval = setInterval(() => { |
|
|
loadProgress += 2; |
|
|
loadingFill.style.width = loadProgress + '%'; |
|
|
|
|
|
if (loadProgress >= 100) { |
|
|
clearInterval(loadInterval); |
|
|
setTimeout(() => { |
|
|
loadingScreen.style.display = 'none'; |
|
|
taskbar.style.display = 'flex'; |
|
|
hfGenerator = new HFDatasetGenerator(); |
|
|
|
|
|
|
|
|
setTimeout(() => { |
|
|
openHFWindow(); |
|
|
}, 300); |
|
|
}, 500); |
|
|
} |
|
|
}, 30); |
|
|
|
|
|
|
|
|
function updateClock() { |
|
|
const now = new Date(); |
|
|
const time = now.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' }); |
|
|
document.getElementById('clock').textContent = time; |
|
|
} |
|
|
setInterval(updateClock, 1000); |
|
|
updateClock(); |
|
|
|
|
|
|
|
|
document.addEventListener('keydown', (e) => { |
|
|
|
|
|
if (e.ctrlKey && e.key === 'g') { |
|
|
e.preventDefault(); |
|
|
if (hfGenerator) hfGenerator.generateDataset(); |
|
|
} |
|
|
|
|
|
|
|
|
if (e.ctrlKey && e.key === 'e') { |
|
|
e.preventDefault(); |
|
|
if (hfGenerator) hfGenerator.exportDataset(); |
|
|
} |
|
|
|
|
|
|
|
|
if (e.key === 'Escape') { |
|
|
closeHFWindow(); |
|
|
} |
|
|
|
|
|
|
|
|
if (e.key.length === 1 && !e.ctrlKey && !e.metaKey) { |
|
|
const input = document.getElementById('hfInput'); |
|
|
if (document.getElementById('hfWindow').classList.contains('active')) { |
|
|
input.focus(); |
|
|
} |
|
|
} |
|
|
}); |
|
|
|
|
|
|
|
|
const hfInput = document.getElementById('hfInput'); |
|
|
hfInput.addEventListener('keypress', (e) => { |
|
|
if (e.key === 'Enter') { |
|
|
if (hfGenerator) hfGenerator.executeCommand(); |
|
|
} |
|
|
}); |
|
|
|
|
|
|
|
|
document.getElementById('sampleCount').dispatchEvent(new Event('input')); |
|
|
document.getElementById('matrixSize').dispatchEvent(new Event('input')); |
|
|
document.getElementById('trainSplit').dispatchEvent(new Event('input')); |
|
|
}); |
|
|
</script> |
|
|
</body> |
|
|
</html> |
|
|
|
