jekyll-theme-pca-cloud 0.1.0

data/assets/js/pca.js

@@ -0,0 +1,91 @@
+// All analysis stays in the browser. No dependencies or network requests.
+export function parseCSV(text) {
+  const rows = []; let row = [], cell = '', quoted = false;
+  text = text.replace(/^\uFEFF/, '');
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === '"') {
+      if (quoted && text[i + 1] === '"') { cell += '"'; i++; }
+      else if (quoted || cell === '') quoted = !quoted;
+      else cell += c;
+    } else if (!quoted && (c === ',' || c === '\n' || c === '\r')) {
+      row.push(cell.trim()); cell = '';
+      if (c !== ',') { if (row.some(v => v !== '')) rows.push(row); row = []; if (c === '\r' && text[i + 1] === '\n') i++; }
+    } else cell += c;
+  }
+  if (quoted) throw new Error('A quoted field is unfinished. Please check your CSV.');
+  row.push(cell.trim()); if (row.some(v => v !== '')) rows.push(row);
+  if (rows.length < 3) throw new Error('Include a header and at least two data rows.');
+  const headers = rows.shift();
+  if (headers.length > 100) throw new Error('Please use a CSV with 100 columns or fewer.');
+  const numeric = v => v !== undefined && v !== '' && Number.isFinite(Number(v));
+  const columns = headers.map((name, index) => ({ name: name || `Column ${index + 1}`, index }))
+    .filter(col => rows.some(r => numeric(r[col.index])) && rows.every(r => r[col.index] === undefined || r[col.index] === '' || numeric(r[col.index])));
+  if (columns.length < 2) throw new Error('PCA needs at least two numeric columns. Remove text values from measurement columns.');
+  const valid = rows.filter(r => r.length === headers.length && columns.every(c => numeric(r[c.index])));
+  if (valid.length < 2) throw new Error('At least two complete numeric rows are needed.');
+  const count = Math.min(valid.length, 2500);
+  const data = Array.from({ length: count }, (_, i) => columns.map(c => Number(valid[Math.floor(i * valid.length / count)][c.index])));
+  return { data, columns: columns.map(c => c.name), skipped: rows.length - valid.length, sampled: valid.length > count, sourceRows: valid.length };
+}
+
+export function prepareData(data, standardize = true) {
+  const n = data.length, d = data[0]?.length;
+  if (n < 2 || !d || data.some(row => row.length !== d || row.some(v => !Number.isFinite(v)))) throw new Error('PCA requires a finite rectangular matrix with at least two rows.');
+  // Scaling all values first avoids overflow for very large CSV measurements.
+  const magnitudes = Array.from({ length: d }, (_, j) => Math.max(...data.map(r => Math.abs(r[j]))) || 1);
+  const commonScale = Math.max(...magnitudes);
+  const scaled = data.map(r => r.map((v, j) => v / (standardize ? magnitudes[j] : commonScale)));
+  const mean = Array.from({ length: d }, (_, j) => scaled.reduce((s, r) => s + r[j], 0) / n);
+  const scales = mean.map((m, j) => standardize ? Math.sqrt(scaled.reduce((s, r) => s + (r[j] - m) ** 2, 0) / (n - 1)) || 1 : 1);
+  const centered = scaled.map(r => r.map((v, j) => (v - mean[j]) / scales[j]));
+  return centered;
+}
+
+export function pca(data, standardize = true) {
+  const centered = prepareData(data, standardize);
+  const n = data.length, d = data[0].length;
+  const a = Array.from({ length: d }, () => Array(d).fill(0));
+  for (let j = 0; j < d; j++) for (let k = j; k < d; k++) a[j][k] = a[k][j] = centered.reduce((s, r) => s + r[j] * r[k], 0) / (n - 1);
+  const total = a.reduce((s, r, j) => s + r[j], 0);
+  if (total < 1e-25) throw new Error('These columns have no variation. Try data with changing measurements.');
+  const vectors = Array.from({ length: d }, (_, i) => Array.from({ length: d }, (_, j) => +(i === j)));
+  // Cyclic Jacobi eigendecomposition of the symmetric covariance matrix.
+  for (let sweep = 0; sweep < 60; sweep++) {
+    let largest = 0;
+    for (let p = 0; p < d; p++) for (let q = p + 1; q < d; q++) {
+      largest = Math.max(largest, Math.abs(a[p][q]));
+      if (Math.abs(a[p][q]) < total * 1e-13) continue;
+      const angle = .5 * Math.atan2(2 * a[p][q], a[q][q] - a[p][p]);
+      const c = Math.cos(angle), s = Math.sin(angle), pp = a[p][p], qq = a[q][q], pq = a[p][q];
+      a[p][p] = c*c*pp - 2*s*c*pq + s*s*qq;
+      a[q][q] = s*s*pp + 2*s*c*pq + c*c*qq; a[p][q] = a[q][p] = 0;
+      for (let k = 0; k < d; k++) {
+        if (k !== p && k !== q) { const kp = a[k][p], kq = a[k][q]; a[k][p] = a[p][k] = c*kp-s*kq; a[k][q] = a[q][k] = s*kp+c*kq; }
+        const vp = vectors[k][p], vq = vectors[k][q]; vectors[k][p] = c*vp-s*vq; vectors[k][q] = s*vp+c*vq;
+      }
+    }
+    if (largest < total * 1e-11) break;
+  }
+  const fullOrder = Array.from({ length: d }, (_, i) => i).sort((i, j) => a[j][j] - a[i][i]);
+  const eigenvalues = fullOrder.map(i => Math.max(0, a[i][i]));
+  const spectrum = eigenvalues.map(value => value / total);
+  const order = fullOrder.slice(0, 3);
+  const components = order.map(i => vectors.map(r => r[i]));
+  const variance = order.map(i => Math.max(0, a[i][i]) / total);
+  const points = centered.map(row => components.map(v => row.reduce((s, x, j) => s + x*v[j], 0)));
+  while (variance.length < 3) { variance.push(0); points.forEach(p => p.push(0)); }
+  const reconstructionError = Math.max(0, 1 - variance.reduce((s, v) => s + v, 0));
+  return { points, variance, components, reconstructionError, spectrum, eigenvalues };
+}
+
+export function sampleData() {
+  let seed = 42;
+  const random = () => { seed = (1664525 * seed + 1013904223) >>> 0; return (seed + 1) / 4294967297; };
+  const normal = () => Math.sqrt(-2 * Math.log(random())) * Math.cos(2 * Math.PI * random());
+  const data = Array.from({ length: 1600 }, () => {
+    const cluster = random(), x = normal() * .7 + (cluster > .6 ? 1.7 : -1), y = normal() * .6 + (cluster > .6 ? .5 : 0), z = normal() * .4;
+    return [18+4*x+y, 65+8*x-4*y+z, 1013+3*x+4*y, 12+2*x+3*z, 8+x-y+2*z, 30+4*x+2*y-z].map(v => v + normal() * .17);
+  });
+  return { data, columns: ['Temperature', 'Humidity', 'Pressure', 'Wind', 'Visibility', 'Dew point'], skipped: 0, sampled: false };
+}

data/assets/js/projection-worker.js

@@ -0,0 +1,7 @@
+import { tsne } from './tsne.js';
+self.onmessage=({data})=>{
+  try {
+    const result=tsne(data.rows,data.options,progress=>self.postMessage({type:'progress',...progress}));
+    self.postMessage({type:'result',result});
+  }catch(error){self.postMessage({type:'error',message:error.message});}
+};

data/assets/js/tsne.js

@@ -0,0 +1,78 @@
+import { prepareData } from './pca.js';
+
+// Exact t-SNE: symmetric Gaussian affinities, Student-t kernel (one degree
+// of freedom), early exaggeration, momentum and adaptive per-coordinate gains.
+// Reference: van der Maaten & Hinton, JMLR 9 (2008), Algorithm 1.
+export function affinities(data, perplexity) {
+  const n = data.length;
+  if (!(perplexity >= 1 && perplexity < n)) throw new Error('Perplexity must be at least 1 and smaller than the row count.');
+  const conditional = new Float64Array(n*n), distances = new Float64Array(n);
+  for (let i=0;i<n;i++) {
+    let minimum=Infinity;
+    for(let j=0;j<n;j++) {
+      distances[j]=data[i].reduce((s,x,k)=>s+(x-data[j][k])**2,0);
+      if(i!==j)minimum=Math.min(minimum,distances[j]);
+    }
+    let beta=1, low=0, high=Infinity;
+    for(let search=0;search<60;search++) {
+      let sum=0, weighted=0;
+      for(let j=0;j<n;j++) {
+        const distance=distances[j]-minimum;
+        const probability=i===j?0:Math.exp(-distance*beta);
+        conditional[i*n+j]=probability;sum+=probability;weighted+=probability*distance;
+      }
+      const entropy=Math.log(sum)+beta*weighted/sum;
+      for(let j=0;j<n;j++)conditional[i*n+j]/=sum;
+      const difference=entropy-Math.log(perplexity);
+      if(Math.abs(difference)<1e-7)break;
+      if(difference>0){low=beta;beta=Number.isFinite(high)?(beta+high)/2:beta*2;}
+      else {high=beta;beta=(beta+low)/2;}
+    }
+  }
+  const p=new Float64Array(n*n);
+  for(let i=0;i<n;i++)for(let j=i+1;j<n;j++)p[i*n+j]=p[j*n+i]=(conditional[i*n+j]+conditional[j*n+i])/(2*n);
+  return p;
+}
+
+export function objective(points, p, exaggeration=1) {
+  const n=points.length, weights=new Float64Array(n*n), gradient=points.map(()=>[0,0,0]);
+  let sum=0, kl=0;
+  for(let i=0;i<n;i++)for(let j=i+1;j<n;j++) {
+    const w=1/(1+points[i].reduce((s,x,k)=>s+(x-points[j][k])**2,0));
+    weights[i*n+j]=weights[j*n+i]=w;sum+=2*w;
+  }
+  for(let i=0;i<n;i++)for(let j=i+1;j<n;j++) {
+    const probability=p[i*n+j], q=weights[i*n+j]/sum;
+    if(probability>0)kl+=2*probability*Math.log(probability/Math.max(q,1e-300));
+    const multiplier=4*(exaggeration*probability-q)*weights[i*n+j];
+    for(let k=0;k<3;k++){const g=multiplier*(points[i][k]-points[j][k]);gradient[i][k]+=g;gradient[j][k]-=g;}
+  }
+  return {gradient,kl};
+}
+
+export function tsne(data, {standardize=true,perplexity=30,iterations=500,seed=42}={}, onProgress=()=>{}) {
+  if(data.length>500)throw new Error('t-SNE supports at most 500 rows per run.');
+  if(!Number.isInteger(iterations)||iterations<1||iterations>2000)throw new Error('Invalid iteration count.');
+  const centered=prepareData(data,standardize),n=centered.length;
+  if(!centered.some(row=>row.some(x=>Math.abs(x)>1e-12)))throw new Error('These columns have no variation.');
+  // Common scaling changes no affinities and improves bandwidth conditioning.
+  const rms=Math.sqrt(centered.reduce((s,r)=>s+r.reduce((a,x)=>a+x*x,0),0)/n)||1;
+  const p=affinities(centered.map(r=>r.map(x=>x/rms)),perplexity);
+  const random=()=>{seed=(1664525*seed+1013904223)>>>0;return (seed+1)/4294967297;};
+  const points=Array.from({length:n},()=>Array.from({length:3},()=>1e-4*Math.sqrt(-2*Math.log(random()))*Math.cos(2*Math.PI*random())));
+  const velocity=points.map(()=>[0,0,0]),gains=points.map(()=>[1,1,1]);
+  for(let step=0;step<iterations;step++) {
+    const {gradient}=objective(points,p,step<100?4:1);
+    const mean=[0,0,0];
+    for(let i=0;i<n;i++)for(let k=0;k<3;k++) {
+      gains[i][k]=Math.sign(gradient[i][k])!==Math.sign(velocity[i][k])?gains[i][k]+.2:Math.max(.01,gains[i][k]*.8);
+      velocity[i][k]=(step<100?.5:.8)*velocity[i][k]-100*gains[i][k]*gradient[i][k];
+      points[i][k]+=velocity[i][k];mean[k]+=points[i][k]/n;
+    }
+    for(const point of points)for(let k=0;k<3;k++)point[k]-=mean[k];
+    if((step+1)%25===0)onProgress({iteration:step+1,iterations});
+  }
+  const {kl}=objective(points,p);
+  if(!Number.isFinite(kl)||points.some(p=>p.some(x=>!Number.isFinite(x))))throw new Error('t-SNE could not find a finite embedding. Try a different perplexity.');
+  return {points,kl,iterations,perplexity};
+}

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-theme-pca-cloud
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Archisa Bhattacharya
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- _includes/footer.html
+- _includes/head.html
+- _includes/header.html
+- _includes/learning.html
+- _includes/studio.html
+- _layouts/default.html
+- _layouts/home.html
+- _layouts/page.html
+- _layouts/post.html
+- assets/cloud.png
+- assets/css/style.css
+- assets/js/app.js
+- assets/js/kaggle.js
+- assets/js/learn.js
+- assets/js/pca.js
+- assets/js/projection-worker.js
+- assets/js/tsne.js
+homepage: https://github.com/archipelagoing/PCACloud
+licenses:
+- Apache-2.0
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.22
+specification_version: 4
+summary: PCA Cloud's sky and glass interface as a reusable Jekyll theme.
+test_files: []