parakeet.js 0.0.2 → 0.0.3

package/docs/parakeet-transformers-js/debug_test.js

@@ -1,84 +0,0 @@
-// Debug test to capture full error
-import fs from 'fs';
-import path from 'path';
-import { ParakeetModel } from './src/parakeet.js';
-import wav from 'wav';
-const { Reader } = wav;
-import { Writable } from 'stream';
-
-function readWav(filePath) {
-  return new Promise((resolve, reject) => {
-    const file = fs.createReadStream(filePath);
-    const reader = new Reader();
-    const samples = [];
-    let sampleRate = 0;
-    let channels = 0;
-
-    const writer = new Writable({
-      write(chunk, encoding, callback) {
-        for (let i = 0; i < chunk.length; i += 2) {
-          samples.push(chunk.readInt16LE(i));
-        }
-        callback();
-      }
-    });
-
-    reader.on('format', (format) => {
-      sampleRate = format.sampleRate;
-      channels = format.channels;
-    });
-
-    file.pipe(reader).pipe(writer);
-
-    writer.on('finish', () => {
-      let monoSamples = new Float32Array(Math.floor(samples.length / channels));
-      for (let i = 0; i < monoSamples.length; i++) {
-        let sum = 0;
-        for (let c = 0; c < channels; c++) {
-          sum += samples[i * channels + c];
-        }
-        monoSamples[i] = (sum / channels) / 32768;
-      }
-      resolve({ audio: monoSamples, sampleRate });
-    });
-
-    writer.on('error', reject);
-    reader.on('error', reject);
-    file.on('error', reject);
-  });
-}
-
-async function main() {
-  try {
-    const modelDir = path.resolve('../sherpa-onnx-parakeet-model');
-    console.log('Loading model from:', modelDir);
-    const model = await ParakeetModel.fromDirectory(modelDir);
-    console.log('Model loaded successfully');
-    
-    const wavPath = path.resolve('../jfk.wav');
-    console.log('Loading audio from:', wavPath);
-    let { audio, sampleRate } = await readWav(wavPath);
-    console.log(`Audio loaded: ${audio.length} samples at ${sampleRate} Hz`);
-
-    // Just test a small portion first
-    const testAudio = audio.slice(0, 16000); // 1 second
-    
-    console.log('Starting transcription...');
-    const result = await model.transcribe(testAudio, sampleRate, { 
-      returnTimestamps: true, 
-      returnConfidences: true, 
-      temperature: 1.2, 
-      debug: true
-    });
-    console.log('Result:', JSON.stringify(result, null, 2));
-  } catch (error) {
-    console.error('Full error details:');
-    console.error('Error message:', error.message);
-    console.error('Error stack:', error.stack);
-    if (error.cause) {
-      console.error('Error cause:', error.cause);
-    }
-  }
-}
-
-main(); 

package/docs/parakeet-transformers-js/dev/inspect_decoder.cjs

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-const ort = require('onnxruntime-node');
-const path = process.argv[2] || 'sherpa-onnx-parakeet-model/decoder.int8.onnx';
-(async () => {
-  const session = await ort.InferenceSession.create(path);
-  console.log('Model:', path);
-  console.log('Inputs:', session.inputNames, 'metaKeys', Object.keys(session.inputMetadata));
-  console.log('Outputs:', session.outputNames);
-})(); 

package/docs/parakeet-transformers-js/dev/inspect_joiner.cjs

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-const ort = require('onnxruntime-node');
-const path = process.argv[2] || 'sherpa-onnx-parakeet-model/joiner.int8.onnx';
-(async () => {
-  const s = await ort.InferenceSession.create(path);
-  console.log('Model', path);
-  console.log('Inputs', Object.keys(s.inputMetadata));
-  console.log('Outputs', s.outputNames);
-})(); 

package/docs/parakeet-transformers-js/dev/js_step_by_step.js

@@ -1,249 +0,0 @@
-#!/usr/bin/env node
-/**
- * Step-by-step intermediate value dumper for JS implementation to compare with onnx-asr.
- */
-
-import fs from 'fs';
-import path from 'path';
-import { ParakeetModel } from '../src/parakeet.js';
-import wav from 'wav';
-import { Writable } from 'stream';
-
-function parseArgs() {
-  const args = process.argv.slice(2);
-  if (args.length < 2) {
-    console.error('Usage: node js_step_by_step.js <model_dir> <audio.wav> [output.json]');
-    process.exit(1);
-  }
-  return {
-    modelDir: args[0],
-    wavPath: args[1],
-    outputFile: args[2] || 'js_step_by_step.json'
-  };
-}
-
-function readWav(filePath) {
-  const buffer = fs.readFileSync(filePath);
-  
-  // Basic WAV header parsing (assumes 16-bit PCM)
-  const sampleRate = buffer.readUInt32LE(24);
-  const bitsPerSample = buffer.readUInt16LE(34);
-  const dataStart = 44; // Standard WAV header size
-  
-  console.log(`WAV: ${sampleRate} Hz, ${bitsPerSample} bits`);
-  
-  // Convert 16-bit PCM to Float32Array
-  const samples = (buffer.length - dataStart) / 2;
-  const audio = new Float32Array(samples);
-  
-  for (let i = 0; i < samples; i++) {
-    const sample = buffer.readInt16LE(dataStart + i * 2);
-    audio[i] = sample / 32768.0; // Normalize to [-1, 1]
-  }
-  
-  return { audio, sampleRate };
-}
-
-async function main() {
-  const { modelDir, wavPath, outputFile } = parseArgs();
-  
-  console.log(`Loading model from: ${modelDir}`);
-  console.log(`Processing audio: ${wavPath}`);
-  
-  const model = await ParakeetModel.fromDirectory(path.resolve(modelDir), { preferFloat32: true });
-  const { audio, sampleRate } = readWav(path.resolve(wavPath));
-  
-  console.log(`Audio: ${audio.length} samples @ ${sampleRate} Hz, duration: ${(audio.length / sampleRate).toFixed(2)}s`);
-  
-  const outputData = {
-    audio_length: audio.length,
-    sample_rate: sampleRate,
-    model_config: {
-      vocab_size: model.tokenizer.id2token.length,
-      blank_idx: model.blankId,
-      max_tokens_per_step: model.maxTokensPerStep,
-      subsampling_factor: model.subsampling,
-      pred_layers: model.predLayers,
-      pred_hidden: model.predHidden
-    },
-    steps: []
-  };
-  
-  // Step 1: Preprocessing
-  console.log("Step 1: Preprocessing...");
-  const features = await model.computeFeatures(audio, sampleRate);
-  const MEL_BINS = 128;
-  const T = features.length / MEL_BINS;
-  
-  outputData.preprocessing = {
-    features_shape: [1, MEL_BINS, T],
-    features_lens: [T],
-    features_sample: Array.from(features.slice(0, 50)).map(v => parseFloat(v.toFixed(6))),
-    features_dtype: "float32"
-  };
-  
-  // Step 2: Manual decoding with step-by-step logging
-  console.log("Step 2: Manual decoding...");
-  
-  const ort = await import('onnxruntime-node');
-  
-  // Correctly initialize variables for decoding loop
-  const tokens = [];
-  const timestamps = [];
-  let decoderState = null;
-  let stepIdx = 0;
-  
-  // --- Start of new non-chunking logic ---
-  
-  // 1. Encode the entire feature set at once
-  const input = new ort.Tensor('float32', features, [1, MEL_BINS, T]);
-  const lenTensor = new ort.Tensor('int64', BigInt64Array.from([BigInt(T)]), [1]);
-  const encOut = await model.encoderSession.run({ 'audio_signal': input, 'length': lenTensor });
-  const enc = encOut['outputs'] ?? Object.values(encOut)[0];
-  
-  // 2. Transpose encoder output to match onnx-asr: [B, D, T] -> [B, T, D]
-  const [B, D, T_enc] = enc.dims;
-  const transposedEncData = new Float32Array(B * T_enc * D);
-  for (let b = 0; b < B; ++b) {
-      for (let t_idx = 0; t_idx < T_enc; ++t_idx) {
-          for (let d = 0; d < D; ++d) {
-              const srcIdx = b * (D * T_enc) + d * T_enc + t_idx;
-              const destIdx = b * (T_enc * D) + t_idx * D + d;
-              transposedEncData[destIdx] = enc.data[srcIdx];
-          }
-      }
-  }
-  const encTransposed = {
-      data: transposedEncData,
-      dims: [B, T_enc, D],
-  };
-  
-  outputData.encoding = {
-    encoder_out_shape: encTransposed.dims,
-    encoder_out_lens: [encTransposed.dims[1]],
-    encoder_out_sample: Array.from(encTransposed.data.slice(0, 50)).map(v => parseFloat(v.toFixed(6))),
-    encoder_out_dtype: "float32"
-  };
-  
-  // 3. Detailed step-by-step decoding loop
-  console.log(`Processing ${T_enc} encoder frames...`);
-  const hiddenSize = encTransposed.dims[2];
-  const seqLen = encTransposed.dims[1];
-  
-  let t = 0;
-  let emittedTokens = 0;
-  
-  while (t < seqLen) {
-    const currFrameIdx = t;
-    
-    // Slice encoder output for timestep t
-    const frameBuf = new Float32Array(hiddenSize);
-    const frameOffset = t * hiddenSize;
-    for (let i = 0; i < hiddenSize; ++i) {
-      frameBuf[i] = encTransposed.data[frameOffset + i];
-    }
-    const encTensor = new ort.Tensor('float32', frameBuf, [1, hiddenSize, 1]);
-  
-    const lastToken = tokens.length > 0 ? tokens[tokens.length - 1] : model.blankId;
-    const res = await model._runCombinedStep(encTensor, lastToken, decoderState);
-    const { tokenLogits, step, newState } = res;
-    
-    let max = -Infinity, maxId = 0;
-    for (let i = 0; i < tokenLogits.length; ++i) {
-      if (tokenLogits[i] > max) { 
-        max = tokenLogits[i]; 
-        maxId = i; 
-      }
-    }
-    
-    const topK = Array.from({length: tokenLogits.length}, (_, i) => ({id: i, logit: tokenLogits[i]}))
-      .sort((a, b) => b.logit - a.logit).slice(0, 5);
-    
-    const stepData = {
-      step: stepIdx,
-      t: t,
-      emitted_tokens: emittedTokens,
-      probs_shape: [tokenLogits.length],
-      token: maxId,
-      token_text: model.tokenizer.id2token[maxId] || `UNK_${maxId}`,
-      is_blank: maxId === model.blankId,
-      step_prediction: step,
-      top_5_tokens: topK.map(({id, logit}) => ({
-        token: id,
-        text: model.tokenizer.id2token[id] || `UNK_${id}`,
-        prob: parseFloat(logit.toFixed(6))
-      })),
-      action: '',
-      advance: 0,
-      advance_reason: ''
-    };
-    
-    if (maxId !== model.blankId) {
-      tokens.push(maxId);
-      timestamps.push(currFrameIdx);
-      decoderState = newState;
-      emittedTokens += 1;
-      stepData.action = "emit_token";
-    } else {
-      stepData.action = "blank";
-    }
-    
-    if (step > 0) {
-      t += step;
-      emittedTokens = 0;
-      stepData.advance = step;
-      stepData.advance_reason = "duration_step";
-    } else if (maxId === model.blankId || emittedTokens >= model.maxTokensPerStep) {
-      t += 1;
-      emittedTokens = 0;
-      stepData.advance = 1;
-      stepData.advance_reason = "blank_or_max_tokens";
-    } else {
-      stepData.advance = 0;
-      stepData.advance_reason = "continue_emitting";
-    }
-    
-    outputData.steps.push(stepData);
-    stepIdx++;
-  }
-  
-  // --- End of new non-chunking logic ---
-  
-  // Step 3: Final results
-  console.log("Step 3: Final results...");
-  
-  // Final results from the step-by-step loop
-  outputData.final_results = {
-    tokens: tokens,
-    timestamps: timestamps,
-    decoded_text: model.tokenizer.decode(tokens),
-    total_steps: stepIdx,
-    final_t: t,
-    encodings_len: T_enc
-  };
-  
-  // Full transcription for comparison, now with timestamps and confidences
-  console.log("Running full transcription for comparison...");
-  const fullResult = await model.transcribe(audio, sampleRate, { 
-    returnTimestamps: true, 
-    returnConfidences: true,
-    debug: true 
-  });
-  outputData.full_transcription = fullResult;
-  
-  // Save results
-  fs.writeFileSync(outputFile, JSON.stringify(outputData, null, 2));
-  
-  console.log(`Step-by-step data saved to: ${outputFile}`);
-  console.log(`Final decoded text from steps: ${outputData.final_results.decoded_text}`);
-  if (typeof fullResult === 'string') {
-    console.log(`Full transcription result: ${fullResult}`);
-  } else {
-    console.log(`Full transcription result: ${fullResult.text}`);
-  }
-}
-
-main().catch(e => { 
-  console.error(e); 
-  process.exit(1); 
-}); 

package/docs/parakeet-transformers-js/dev/parakeet_cli.js

@@ -1,91 +0,0 @@
-#!/usr/bin/env node
-// Simple CLI to transcribe a WAV file with ParakeetModel.
-// Usage: parakeet_cli.js <model_dir> <audio.wav> [--json]
-import fs from 'fs';
-import path from 'path';
-import { ParakeetModel } from '../src/parakeet.js';
-import wav from 'wav';
-import { Writable } from 'stream';
-
-function parseArgs() {
-  const args = process.argv.slice(2);
-  if (args.length < 2) {
-    console.error('Usage: parakeet_cli.js <model_dir> <audio.wav> [--json] [--debug]');
-    process.exit(1);
-  }
-  const opts = { 
-    modelDir: args[0], 
-    wavPath: args[1], 
-    json: args.includes('--json'),
-    debug: args.includes('--debug'),
-    float32: args.includes('--float32') || args.includes('--fp32')
-  };
-  return opts;
-}
-
-function readWav(filePath) {
-  return new Promise((resolve, reject) => {
-    const file = fs.createReadStream(filePath);
-    const reader = new wav.Reader();
-    const samples = [];
-    let sampleRate = 0;
-    let channels = 0;
-
-    const writer = new Writable({
-      write(chunk, _enc, cb) {
-        for (let i = 0; i < chunk.length; i += 2) {
-          samples.push(chunk.readInt16LE(i));
-        }
-        cb();
-      }
-    });
-
-    reader.on('format', (fmt) => { sampleRate=fmt.sampleRate; channels=fmt.channels; });
-    file.pipe(reader).pipe(writer);
-
-    writer.on('finish', () => {
-      const mono = new Float32Array(Math.floor(samples.length / channels));
-      for (let i=0;i<mono.length;++i){
-        let sum=0; for(let c=0;c<channels;++c){ sum+=samples[i*channels+c]; }
-        mono[i]=sum/channels/32768;
-      }
-      resolve({ audio: mono, sampleRate });
-    });
-    writer.on('error', reject);
-    reader.on('error', reject);
-    file.on('error', reject);
-  });
-}
-
-async function main(){
-  const { modelDir, wavPath, json, debug, float32 } = parseArgs();
-  const model = await ParakeetModel.fromDirectory(path.resolve(modelDir), { preferFloat32: float32 });
-  const { audio, sampleRate } = await readWav(path.resolve(wavPath));
-  const padded = new Float32Array(audio.length + sampleRate*2);
-  padded.set(audio);
-  const result = await model.transcribe(padded, sampleRate, { 
-    returnTimestamps: true, 
-    returnConfidences: true, 
-    temperature: 1.2,
-    debug: debug
-  });
-  const wrapped = { utterance: 1, ...result };
-
-  if (json) {
-    console.log(JSON.stringify(wrapped, null, 2));
-  } else {
-    console.log(result.text);
-  }
-
-  // Always write detailed JSON output to a file for diffing / inspection
-  const quantTag = float32 ? 'fp32' : 'int8';
-  const outPath = path.resolve(`transcription_output_js_${quantTag}.json`);
-  try {
-    await fs.promises.writeFile(outPath, JSON.stringify(wrapped, null, 2));
-    if (debug) console.log(`[ParakeetCLI] Wrote JSON output to ${outPath}`);
-  } catch (e) {
-    console.error(`[ParakeetCLI] Failed to write JSON output:`, e);
-  }
-}
-
-main().catch(e=>{ console.error(e); process.exit(1); }); 

package/docs/parakeet-transformers-js/jest.config.mjs

@@ -1,194 +0,0 @@
-/*
- * For a detailed explanation regarding each configuration property, visit:
- * https://jestjs.io/docs/configuration
- */
-
-export default {
-  // All imported modules in your tests should be mocked automatically
-  // automock: false,
-
-  // Stop running tests after `n` failures
-  // bail: 0,
-
-  // Automatically clear mock calls, instances, contexts and results before every test
-  clearMocks: true,
-
-  // Set timeout for long-running ONNX tests
-  testTimeout: 30000,
-
-  // Indicates whether the coverage information should be collected while executing the test
-  collectCoverage: true,
-
-  // An array of glob patterns indicating a set of files for which coverage information should be collected
-  // collectCoverageFrom: undefined,
-
-  // The directory where Jest should output its coverage files
-  coverageDirectory: "coverage",
-
-  // An array of regexp pattern strings used to skip coverage collection
-  coveragePathIgnorePatterns: [
-    "node_modules",
-    "tests",
-  ],
-
-  // Indicates which provider should be used to instrument code for coverage
-  coverageProvider: "v8",
-
-  // A list of reporter names that Jest uses when writing coverage reports
-  // coverageReporters: [
-  //   "json",
-  //   "text",
-  //   "lcov",
-  //   "clover"
-  // ],
-
-  // An object that configures minimum threshold enforcement for coverage results
-  // coverageThreshold: undefined,
-
-  // A path to a custom dependency extractor
-  // dependencyExtractor: undefined,
-
-  // Make calling deprecated APIs throw helpful error messages
-  // errorOnDeprecated: false,
-
-  // The default configuration for fake timers
-  // fakeTimers: {
-  //   "enableGlobally": false
-  // },
-
-  // Force coverage collection from ignored files using an array of glob patterns
-  // forceCoverageMatch: [],
-
-  // A path to a module which exports an async function that is triggered once before all test suites
-  // globalSetup: undefined,
-
-  // A path to a module which exports an async function that is triggered once after all test suites
-  // globalTeardown: undefined,
-
-  // A set of global variables that need to be available in all test environments
-  // globals: {},
-
-  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
-  // maxWorkers: "50%",
-
-  // An array of directory names to be searched recursively up from the requiring module's location
-  // moduleDirectories: [
-  //   "node_modules"
-  // ],
-
-  // An array of file extensions your modules use
-  // moduleFileExtensions: [
-  //   "js",
-  //   "mjs",
-  //   "cjs",
-  //   "jsx",
-  //   "ts",
-  //   "tsx",
-  //   "json",
-  //   "node"
-  // ],
-
-  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
-  // moduleNameMapper: {},
-
-  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
-  // modulePathIgnorePatterns: [],
-
-  // Activates notifications for test results
-  // notify: false,
-
-  // An enum that specifies notification mode. Requires { notify: true }
-  // notifyMode: "failure-change",
-
-  // A preset that is used as a base for Jest's configuration
-  // preset: undefined,
-
-  // Run tests from one or more projects
-  // projects: undefined,
-
-  // Use this configuration option to add custom reporters to Jest
-  // reporters: undefined,
-
-  // Automatically reset mock state before every test
-  // resetMocks: false,
-
-  // Reset the module registry before running each individual test
-  // resetModules: false,
-
-  // A path to a custom resolver
-  // resolver: undefined,
-
-  // Automatically restore mock state and implementation before every test
-  // restoreMocks: false,
-
-  // The root directory that Jest should scan for tests and modules within
-  // rootDir: undefined,
-
-  // A list of paths to directories that Jest should use to search for files in
-  roots: ["./test/"],
-
-  // Allows you to use a custom runner instead of Jest's default test runner
-  // runner: "jest-runner",
-
-  // The paths to modules that run some code to configure or set up the testing environment before each test
-  // setupFiles: [],
-
-  // A list of paths to modules that run some code to configure or set up the testing framework before each test
-  // setupFilesAfterEnv: [],
-
-  // The number of seconds after which a test is considered as slow and reported as such in the results.
-  // slowTestThreshold: 5,
-
-  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
-  // snapshotSerializers: [],
-
-  // The test environment that will be used for testing
-  // testEnvironment: "jest-environment-node",
-
-  // Options that will be passed to the testEnvironment
-  // testEnvironmentOptions: {},
-
-  // Adds a location field to test results
-  // testLocationInResults: false,
-
-  // The glob patterns Jest uses to detect test files
-  // testMatch: [
-  //   "**/__tests__/**/*.[jt]s?(x)",
-  //   "**/?(*.)+(spec|test).[tj]s?(x)"
-  // ],
-
-  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
-  // testPathIgnorePatterns: [
-  //   "\\\\node_modules\\\\"
-  // ],
-
-  // The regexp pattern or array of patterns that Jest uses to detect test files
-  // testRegex: [],
-
-  // This option allows the use of a custom results processor
-  // testResultsProcessor: undefined,
-
-  // This option allows use of a custom test runner
-  // testRunner: "jest-circus/runner",
-
-  // A map from regular expressions to paths to transformers
-  transform: {},
-
-  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
-  // transformIgnorePatterns: [
-  //   "\\\\node_modules\\\\",
-  //   "\\.pnp\\.[^\\\\]+$"
-  // ],
-
-  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
-  // unmockedModulePathPatterns: undefined,
-
-  // Indicates whether each individual test should be reported during the run
-  // verbose: undefined,
-
-  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
-  // watchPathIgnorePatterns: [],
-
-  // Whether to use watchman for file crawling
-  // watchman: true,
-};