echogarden 1.8.2 → 1.8.4

package/src/math/VectorMath.ts

@@ -1,6 +1,6 @@
 import { clip } from "../utilities/Utilities.js"
 
-export function covarianceMatrixOfSamples(samples: number[][], weights?: number[], biased = false) {
+export function covarianceMatrixOfSamples(samples: ArrayLike<number>[], weights?: ArrayLike<number>, biased = false) {
 	if (samples.length == 0) {
 		throw new Error('No vectors given')
 	}
@@ -18,7 +18,7 @@ export function covarianceMatrixOfSamples(samples: number[][], weights?: number[
 	return { covarianceMatrix, mean }
 }
 
-export function covarianceMatrixOfCenteredSamples(centeredSamples: number[][], biased = false, diagonalRegularizationAmount = 1e-6) {
+export function covarianceMatrixOfCenteredSamples(centeredSamples: ArrayLike<number>[], biased = false, diagonalRegularizationAmount = 1e-6) {
 	const sampleCount = centeredSamples.length
 
 	if (sampleCount == 0) {
@@ -60,7 +60,7 @@ export function covarianceMatrixOfCenteredSamples(centeredSamples: number[][], b
 	return covarianceMatrix
 }
 
-export function weightedCovarianceMatrixOfCenteredSamples(centeredSamples: number[][], weights: number[], diagonalRegularizationAmount = 1e-6) {
+export function weightedCovarianceMatrixOfCenteredSamples(centeredSamples: ArrayLike<number>[], weights: ArrayLike<number>, diagonalRegularizationAmount = 1e-6) {
 	const sampleCount = centeredSamples.length
 
 	if (sampleCount == 0) {
@@ -102,33 +102,36 @@ export function weightedCovarianceMatrixOfCenteredSamples(centeredSamples: numbe
 	return covarianceMatrix
 }
 
-export function centerVectors(vectors: number[][], weights?: number[]) {
+export function centerVectors(vectors: ArrayLike<number>[], weights?: ArrayLike<number>) {
 	const vectorCount = vectors.length
 
 	if (vectorCount == 0) {
-		return { centeredVectors: [], mean: [] }
+		return { centeredVectors: [] as Float32Array[], mean: new Float32Array(0) }
 	}
 
-	let mean: number[]
+	let mean: Float32Array
+
 	if (weights) {
 		mean = weightedMeanOfVectors(vectors, weights)
 	} else {
 		mean = meanOfVectors(vectors)
 	}
 
-	const centeredVectors: number[][] = new Array(vectorCount)
+	const centeredVectors: Float32Array[] = []
 
 	for (let i = 0; i < vectorCount; i++) {
-		centeredVectors[i] = subtractVectors(vectors[i], mean)
+		const centeredVector = subtractVectors(vectors[i], mean)
+
+		centeredVectors.push(centeredVector)
 	}
 
 	return { centeredVectors, mean }
 }
 
-export function centerVector(vector: number[]) {
+export function centerVector(vector: ArrayLike<number>) {
 	const mean = meanOfVector(vector)
 
-	const centeredVector: number[] = new Array(vector.length)
+	const centeredVector = new Float32Array(vector.length)
 
 	for (let i = 0; i < vector.length; i++) {
 		centeredVector[i] = vector[i] - mean
@@ -137,18 +140,18 @@ export function centerVector(vector: number[]) {
 	return centeredVector
 }
 
-export function scaleToSumTo1(vector: number[]) {
+export function scaleToSumTo1(vector: ArrayLike<number>) {
 	if (vector.length == 0) {
-		return []
+		return new Float32Array(0)
 	}
 
 	if (vector.length == 1) {
-		return [1]
+		return Float32Array.from([1])
 	}
 
 	const minValue = vector[indexOfMin(vector)]
 
-	const scaledVector = vector.slice()
+	const scaledVector = Float32Array.from(vector)
 
 	if (minValue < 0) {
 		const addedOffset = -minValue * 2
@@ -196,11 +199,11 @@ export function normalizeVector(vector: ArrayLike<number>, kind: 'population' |
 	return { normalizedVector, mean, stdDeviation }
 }
 
-export function normalizeVectors(vectors: number[][], kind: 'population' | 'sample' = 'population') {
+export function normalizeVectors(vectors: ArrayLike<number>[], kind: 'population' | 'sample' = 'population') {
 	const vectorCount = vectors.length
 
 	if (vectorCount == 0) {
-		return { normalizedVectors: [], mean: [], stdDeviation: [] }
+		return { normalizedVectors: [] as Float32Array[], mean: new Float32Array(0), stdDeviation: new Float32Array(0) }
 	}
 
 	const featureCount = vectors[0].length
@@ -208,7 +211,7 @@ export function normalizeVectors(vectors: number[][], kind: 'population' | 'samp
 	const mean = meanOfVectors(vectors)
 	const stdDeviation = stdDeviationOfVectors(vectors, kind, mean)
 
-	const normalizedVectors: number[][] = []
+	const normalizedVectors: Float32Array[] = []
 
 	for (const vector of vectors) {
 		const normalizedVector = createVector(featureCount)
@@ -225,16 +228,16 @@ export function normalizeVectors(vectors: number[][], kind: 'population' | 'samp
 	return { normalizedVectors, mean, stdDeviation }
 }
 
-export function deNormalizeVectors(normalizedVectors: number[][], originalMean: number[], originalStdDeviation: number[]) {
+export function deNormalizeVectors(normalizedVectors: ArrayLike<number>[], originalMean: ArrayLike<number>, originalStdDeviation: ArrayLike<number>) {
 	const vectorCount = normalizeVectors.length
 
 	if (vectorCount == 0) {
-		return []
+		return [] as Float32Array[]
 	}
 
 	const featureCount = normalizedVectors[0].length
 
-	const deNormalizedVectors: number[][] = []
+	const deNormalizedVectors: Float32Array[] = []
 
 	for (const normalizedVector of normalizedVectors) {
 		const deNormalizedVector = createVector(featureCount)
@@ -249,11 +252,11 @@ export function deNormalizeVectors(normalizedVectors: number[][], originalMean:
 	return deNormalizedVectors
 }
 
-export function meanOfVectors(vectors: number[][]) {
+export function meanOfVectors(vectors: ArrayLike<number>[]) {
 	const vectorCount = vectors.length
 
 	if (vectorCount == 0) {
-		return []
+		return new Float32Array(0)
 	}
 
 	const featureCount = vectors[0].length
@@ -273,11 +276,11 @@ export function meanOfVectors(vectors: number[][]) {
 	return result
 }
 
-export function weightedMeanOfVectors(vectors: number[][], weights: number[]) {
+export function weightedMeanOfVectors(vectors: ArrayLike<number>[], weights: ArrayLike<number>) {
 	const vectorCount = vectors.length
 
 	if (vectorCount == 0) {
-		return []
+		return new Float32Array(0)
 	}
 
 	const featureCount = vectors[0].length
@@ -296,15 +299,15 @@ export function weightedMeanOfVectors(vectors: number[][], weights: number[]) {
 	return result
 }
 
-export function stdDeviationOfVectors(vectors: number[][], kind: 'population' | 'sample' = 'population', mean?: number[]) {
+export function stdDeviationOfVectors(vectors: ArrayLike<number>[], kind: 'population' | 'sample' = 'population', mean?: ArrayLike<number>) {
 	return varianceOfVectors(vectors, kind, mean).map(v => Math.sqrt(v))
 }
 
-export function varianceOfVectors(vectors: number[][], kind: 'population' | 'sample' = 'population', mean?: number[]) {
+export function varianceOfVectors(vectors: ArrayLike<number>[], kind: 'population' | 'sample' = 'population', mean?: ArrayLike<number>) {
 	const vectorCount = vectors.length
 
 	if (vectorCount == 0) {
-		return []
+		return new Float32Array(0)
 	}
 
 	const sampleSizeMetric = kind == 'population' || vectorCount == 1 ? vectorCount : vectorCount - 1
@@ -369,15 +372,31 @@ export function varianceOfVector(vector: ArrayLike<number>, kind: 'population' |
 	return result / sampleSizeMetric
 }
 
-export function logOfVector(vector: number[], minVal = 1e-40) {
-	return vector.map(value => Math.log(value + minVal))
+export function logOfVector(vector: ArrayLike<number>, minVal = 1e-40) {
+	const result = new Float32Array(vector.length)
+
+	for (let i = 0; i < vector.length; i++) {
+		const value = vector[i]
+
+		result[i] = Math.log(value + minVal)
+	}
+
+	return result
 }
 
-export function expOfVector(vector: number[]) {
-	return vector.map(value => Math.exp(value))
+export function expOfVector(vector: ArrayLike<number>) {
+	const result = new Float32Array(vector.length)
+
+	for (let i = 0; i < vector.length; i++) {
+		const value = vector[i]
+
+		result[i] = Math.exp(value)
+	}
+
+	return result
 }
 
-export function transpose(matrix: number[][]) {
+export function transpose(matrix: ArrayLike<number>[]) {
 	const vectorCount = matrix.length
 	const featureCount = matrix[0].length
 
@@ -392,31 +411,31 @@ export function transpose(matrix: number[][]) {
 	return transposedMatrix
 }
 
-export function movingAverageOfWindow3(vector: number[]) {
+export function movingAverageOfWindow3(vector: ArrayLike<number>) {
 	const elementCount = vector.length
 
 	if (elementCount == 0) {
-		return []
+		return new Float32Array(0)
 	}
 
 	if (elementCount == 1) {
-		return vector.slice()
+		return Float32Array.from(vector)
 	}
 
-	const result: number[] = []
+	const result = new Float32Array(elementCount)
 
-	result.push((vector[0] + vector[0] + vector[1]) / 3)
+	result[0] = (vector[0] + vector[0] + vector[1]) / 3
 
 	for (let i = 1; i < elementCount - 1; i++) {
-		result.push((vector[i - 1] + vector[i] + vector[i + 1]) / 3)
+		result[i] = (vector[i - 1] + vector[i] + vector[i + 1]) / 3
 	}
 
-	result.push((vector[elementCount - 2] + vector[elementCount - 1] + vector[elementCount - 1]) / 3)
+	result[elementCount - 1] = (vector[elementCount - 2] + vector[elementCount - 1] + vector[elementCount - 1]) / 3
 
 	return result
 }
 
-export function averageMeanSquaredError(actual: number[][], expected: number[][]) {
+export function averageMeanSquaredError(actual: ArrayLike<number>[], expected: ArrayLike<number>[]) {
 	if (actual.length != expected.length) {
 		throw new Error('Vectors are not the same length')
 	}
@@ -592,14 +611,16 @@ export function minkowskiDistance(vector1: ArrayLike<number>, vector2: ArrayLike
 	return sum ** (1 / power)
 }
 
-export function subtractVectors(vector1: number[], vector2: number[]) {
+export function subtractVectors(vector1: ArrayLike<number>, vector2: ArrayLike<number>) {
+	const elementCount = vector1.length
+
 	if (vector1.length != vector2.length) {
 		throw new Error('Vectors are not the same length')
 	}
 
 	const result = createVector(vector1.length)
 
-	for (let i = 0; i < vector1.length; i++) {
+	for (let i = 0; i < elementCount; i++) {
 		result[i] = vector1[i] - vector2[i]
 	}
 
@@ -607,15 +628,29 @@ export function subtractVectors(vector1: number[], vector2: number[]) {
 }
 
 export function sumVector(vector: ArrayLike<number>) {
+	const elementCount = vector.length
+
 	let result = 0.0
 
-	for (let i = 0; i < vector.length; i++) {
+	for (let i = 0; i < elementCount; i++) {
 		result += vector[i]
 	}
 
 	return result
 }
 
+export function sumOfSquaresForVector(vector: ArrayLike<number>) {
+	const elementCount = vector.length
+
+	let result = 0.0
+
+	for (let i = 0; i < elementCount; i++) {
+		result += vector[i] ** 2
+	}
+
+	return result
+}
+
 export function dotProduct(vector1: ArrayLike<number>, vector2: ArrayLike<number>) {
 	if (vector1.length != vector2.length) {
 		throw new Error('Vectors are not the same length')
@@ -671,10 +706,11 @@ export function minValue(vector: ArrayLike<number>) {
 }
 
 export function indexOfMin(vector: ArrayLike<number>) {
+	const elementCount = vector.length
 	let minValue = Infinity
 	let result = -1
 
-	for (let i = 0; i < vector.length; i++) {
+	for (let i = 0; i < elementCount; i++) {
 		if (vector[i] < minValue) {
 			minValue = vector[i]
 			result = i
@@ -690,40 +726,46 @@ export function sigmoid(x: number) {
 	return zeroIfNaN(result)
 }
 
-export function softmax(logits: number[], temperature = 1.0) {
-	if (logits.length === 0) {
-		return []
+export function softmax(logits: ArrayLike<number>, temperature = 1.0) {
+	const logitCount = logits.length
+
+	if (logitCount === 0) {
+		return new Float32Array(0)
 	}
 
 	let maxValue = -Infinity
 
-	for (const val of logits) {
-		if (val > maxValue) {
-			maxValue = val
+	for (let i = 0; i < logitCount; i++) {
+		const value = logits[i]
+
+		if (value > maxValue) {
+			maxValue = value
 		}
 	}
 
 	const temperatureReciprocal = 1 / (temperature + 1e-40)
 
-	const result: number[] = []
+	const results = new Float32Array(logitCount)
 
 	let sumOfExponentiatedValues = 0.0
 
-	for (const value of logits) {
+	for (let i = 0; i < logitCount; i++) {
+		const value = logits[i]
+
 		const eToValue = Math.exp((value - maxValue) * temperatureReciprocal)
 
 		sumOfExponentiatedValues += eToValue
 
-		result.push(eToValue)
+		results[i] = eToValue
 	}
 
 	const sumOfExponentiatedValuesReciprocal = 1 / (sumOfExponentiatedValues + 1e-40)
 
-	for (let i = 0; i < result.length; i++) {
-		result[i] *= sumOfExponentiatedValuesReciprocal
+	for (let i = 0; i < logitCount; i++) {
+		results[i] *= sumOfExponentiatedValuesReciprocal
 	}
 
-	return result
+	return results
 }
 
 export function hammingDistance(value1: number, value2: number, bitLength = 32) {
@@ -740,7 +782,7 @@ export function hammingDistance(value1: number, value2: number, bitLength = 32)
 }
 
 export function createVectorArray(vectorCount: number, featureCount: number, initialValue = 0.0) {
-	const result: number[][] = new Array(vectorCount)
+	const result: Float32Array[] = new Array(vectorCount)
 
 	for (let i = 0; i < vectorCount; i++) {
 		result[i] = createVector(featureCount, initialValue)
@@ -750,25 +792,15 @@ export function createVectorArray(vectorCount: number, featureCount: number, ini
 }
 
 export function createVector(elementCount: number, initialValue = 0.0) {
-	const result: number[] = new Array(elementCount)
+	const result = new Float32Array(elementCount)
 
-	for (let i = 0; i < elementCount; i++) {
-		result[i] = initialValue
+	if (initialValue !== 0) {
+		result.fill(initialValue)
 	}
 
 	return result
 }
 
-export function createVectorForIntegerRange(start: number, end: number) {
-	const newVector: number[] = []
-
-	for (let i = start; i < end; i++) {
-		newVector.push(i)
-	}
-
-	return newVector
-}
-
 export function zeroIfNaN(val: number) {
 	if (isNaN(val)) {
 		return 0
@@ -777,21 +809,23 @@ export function zeroIfNaN(val: number) {
 	}
 }
 
-export function logSumExp(values: number[], minVal = 1e-40) {
+export function logSumExp(values: ArrayLike<number>, minVal = 1e-40) {
 	return Math.log(minVal + sumExp(values))
 }
 
-export function sumExp(values: number[]) {
+export function sumExp(values: ArrayLike<number>) {
 	let sumOfExp = 0
 
-	for (const value of values) {
+	for (let i = 0; i < values.length; i++) {
+		const value = values[i]
+
 		sumOfExp += Math.exp(value)
 	}
 
 	return sumOfExp
 }
 
-export function logSoftmax(values: number[], minVal = 1e-40) {
+export function logSoftmax(values: ArrayLike<number>, minVal = 1e-40) {
 	const softMaxOfValues = softmax(values)
 
 	return logOfVector(softMaxOfValues, minVal)
@@ -814,7 +848,7 @@ export class IncrementalMean {
 	// 3.81
 }
 
-export type DistanceFunction = (a: number[], b: number[]) => number
+export type DistanceFunction = (a: ArrayLike<number>, b: ArrayLike<number>) => number
 
 export interface ComplexNumber {
 	real: number

package/src/recognition/WhisperSTT.ts

@@ -2,8 +2,8 @@ import type * as Onnx from 'onnxruntime-node'
 
 import { Logger } from '../utilities/Logger.js'
 import { computeMelSpectogramUsingFilterbanks, Filterbank } from '../dsp/MelSpectogram.js'
-import { clip, getIntegerRange, splitFloat32Array, yieldToEventLoop } from '../utilities/Utilities.js'
-import { indexOfMax, logOfVector, logSumExp, meanOfVector, softmax, stdDeviationOfVector } from '../math/VectorMath.js'
+import { clip, concatFloat32Arrays, getIntegerRange, splitFloat32Array, yieldToEventLoop } from '../utilities/Utilities.js'
+import { indexOfMax, logOfVector, logSumExp, meanOfVector, softmax, stdDeviationOfVector, sumOfSquaresForVector, sumVector } from '../math/VectorMath.js'
 
 import { alignDTWWindowed } from '../alignment/DTWSequenceAlignmentWindowed.js'
 import { extendDeep } from '../utilities/ObjectUtilities.js'
@@ -373,6 +373,10 @@ export class Whisper {
 		options = extendDeep(defaultWhisperOptions, options)
 		options.model = this.modelName
 
+		if (!options.timestampAccuracy) {
+			options.timestampAccuracy = this.defaultTimestampAccuracy
+		}
+
 		const audioSamples = rawAudio.audioChannels[0]
 		const sampleRate = rawAudio.sampleRate
 		const prompt = options.prompt
@@ -467,7 +471,7 @@ export class Whisper {
 			// Find alignment path
 			let alignmentHeads: number[] | undefined
 
-			if (options.timestampAccuracy === 'medium') {
+			if (options.timestampAccuracy === 'medium' || options.model == 'large-v3-turbo') {
 				alignmentHeads = this.alignmentHeadIndexes
 			} else if (options.timestampAccuracy === 'high') {
 				alignmentHeads = undefined
@@ -517,6 +521,10 @@ export class Whisper {
 
 		whisperAlignmentOptions = extendDeep(defaultWhisperAlignmentOptions, whisperAlignmentOptions)
 
+		if (!whisperAlignmentOptions.timestampAccuracy) {
+			whisperAlignmentOptions.timestampAccuracy = this.defaultTimestampAccuracy
+		}
+
 		const targetLanguage = task === 'transcribe' ? sourceLanguage : 'en'
 
 		const shouldSplitToSentences = false
@@ -1389,19 +1397,14 @@ export class Whisper {
 		const frameCount = qksTensors[0].dims[4]
 
 		if (!headIndexes) {
-			headIndexes = []
-
-			for (let i = 0; i < layerCount * headCount; i++) {
-				//for (let i = Math.floor(layerCount * headCount / 2); i < layerCount * headCount; i++) {
-				headIndexes.push(i)
-			}
+			headIndexes = getIntegerRange(0, layerCount * headCount)
 		}
 
 		// Load attention head weights from tensors
-		const attentionHeads: number[][][] = [] // structure: [heads, tokens, frames]
+		const attentionHeads: Float32Array[][] = [] // structure: [heads, tokens, frames]
 
 		for (const headIndex of headIndexes) {
-			const attentionHead: number[][] = [] // structure: [tokens, frames]
+			const attentionHead: Float32Array[] = [] // structure: [tokens, frames]
 
 			for (let tokenIndex = 0; tokenIndex < tokenCount; tokenIndex++) {
 				const bufferOffset = headIndex * frameCount
@@ -1410,7 +1413,7 @@ export class Whisper {
 
 				const framesForHead = qksTensors[tokenIndex].data.slice(startIndexInBuffer, endIndexInBuffer)
 
-				attentionHead.push(Array.from(framesForHead as any))
+				attentionHead.push(framesForHead)
 			}
 
 			attentionHeads.push(attentionHead)
@@ -1435,10 +1438,19 @@ export class Whisper {
 		// Normalize all weights in each individual head, if enabled
 		if (normalize) {
 			for (const head of attentionHeads) {
-				const allWeightsForHead = head.flatMap(tokenFrames => tokenFrames)
+				let sumOfAllWeightsForHead = 0
+				let sumOfAllSquaredWeightsForHead = 0
+				let countOfAllWeightsForHead = 0
+
+				for (const tokenFrames of head) {
+					sumOfAllWeightsForHead += sumVector(tokenFrames)
+					sumOfAllSquaredWeightsForHead += sumOfSquaresForVector(tokenFrames)
+					countOfAllWeightsForHead += tokenFrames.length
+				}
 
-				const meanOfAllWeightsForHead = meanOfVector(allWeightsForHead)
-				const stdDeviationOfAllWeightsForHead = stdDeviationOfVector(allWeightsForHead, 'population', meanOfAllWeightsForHead) + 1e-10
+				const meanOfAllWeightsForHead = sumOfAllWeightsForHead / countOfAllWeightsForHead
+				const varianceOfAllWeightsForHead = sumOfAllSquaredWeightsForHead / countOfAllWeightsForHead
+				const stdDeviationOfAllWeightsForHead = Math.sqrt(varianceOfAllWeightsForHead)
 
 				const stdDeviationReciprocal = 1.0 / (stdDeviationOfAllWeightsForHead + 1e-10)
 
@@ -1459,16 +1471,12 @@ export class Whisper {
 			}
 		}
 
-		// Compute the mean for all layers and heads
-		const frameMeansForToken: number[][] = []
-
-		for (let i = 0; i < tokenCount; i++) {
-			const frameMeans = new Array(segmentFrameCount)
-
-			frameMeansForToken.push(frameMeans)
-		}
+		// Compute the mean of the selected attention heads for all layers
+		const frameMeansForToken: Float32Array[] = []
 
 		for (let tokenIndex = 0; tokenIndex < tokenCount; tokenIndex++) {
+			const meansForFrames = new Float32Array(segmentFrameCount)
+
 			for (let frameIndex = 0; frameIndex < segmentFrameCount; frameIndex++) {
 				let sum = 0
 
@@ -1478,8 +1486,10 @@ export class Whisper {
 
 				const frameMean = sum / attentionHeads.length
 
-				frameMeansForToken[tokenIndex][frameIndex] = frameMean
+				meansForFrames[frameIndex] = frameMean
 			}
+
+			frameMeansForToken.push(meansForFrames)
 		}
 
 		// Anchor timestamp tokens timestamps to their original values, if enabled
@@ -1499,7 +1509,7 @@ export class Whisper {
 			}
 		}
 
-		// Perform DTW
+		// Perform DTW to align tokens indexes to frame indexes
 		const tokenIndexes = getIntegerRange(0, tokenCount)
 		const frameIndexes = getIntegerRange(0, segmentFrameCount)
 
@@ -1773,6 +1783,14 @@ export class Whisper {
 		return alignmentHeadsIndexes[this.modelName]
 	}
 
+	get defaultTimestampAccuracy() {
+		if (this.modelName.startsWith('tiny') || this.modelName.startsWith('base')) {
+			return 'high'
+		} else {
+			return 'medium'
+		}
+	}
+
 	getSuppressedTokens() {
 		return [
 			...this.getSuppressedTextTokens(),
@@ -2521,7 +2539,7 @@ export const defaultWhisperOptions: WhisperOptions = {
 	decodeTimestampTokens: true,
 	endTokenThreshold: 0.9,
 	includeEndTokenInCandidates: true,
-	timestampAccuracy: 'medium',
+	timestampAccuracy: undefined,
 	encoderProvider: undefined,
 	decoderProvider: undefined,
 	seed: undefined,
@@ -2542,7 +2560,7 @@ export const defaultWhisperAlignmentOptions: WhisperAlignmentOptions = {
 	model: undefined,
 	endTokenThreshold: 0.9,
 	maxTokensPerPart: 250,
-	timestampAccuracy: 'medium',
+	timestampAccuracy: undefined,
 
 	encoderProvider: undefined,
 	decoderProvider: undefined,

package/src/speech-search/DTWSpeechSearch.ts

@@ -0,0 +1,26 @@
+import { DtwGranularity, getMfccOptionsForGranularity } from "../alignment/SpeechAlignment.js";
+import { RawAudio } from "../audio/AudioUtilities.js";
+import { computeMFCCs, extendDefaultMfccOptions, MfccOptions } from "../dsp/MFCC.js";
+import { Logger } from "../utilities/Logger.js";
+
+export async function searchSpeech(sourceRawAudio: RawAudio, referenceRawAudio: RawAudio) {
+	const logger = new Logger()
+
+	const granularity: DtwGranularity = 'low'
+
+	const mfccOptions = extendDefaultMfccOptions({ ...getMfccOptionsForGranularity(granularity), zeroFirstCoefficient: true }) as MfccOptions
+
+	// Compute reference MFCCs
+	logger.start('Compute reference MFCC features')
+	const referenceMfccs = await computeMFCCs(referenceRawAudio, mfccOptions)
+
+	// Compute source MFCCs
+	logger.start('Compute source MFCC features')
+	const sourceMfccs = await computeMFCCs(sourceRawAudio, mfccOptions)
+
+	logger.start('Compute source MFCC features')
+}
+
+function computeCostMatrix<T, U>(sequence1: T[], sequence2: U[]) {
+	
+}

package/src/utilities/RandomGenerator.ts

@@ -29,7 +29,7 @@ export abstract class RandomGenerator {
 		return result
 	}
 
-	getNormallyDistributedVector(elementCount: number, meanVector: number[], standardDeviationVector: number[]) {
+	getNormallyDistributedVector(elementCount: number, meanVector: ArrayLike<number>, standardDeviationVector: ArrayLike<number>) {
 		const features = this.getNormallyDistributedValues(elementCount)
 
 		for (let i = 0; i < features.length; i++) {
@@ -78,7 +78,7 @@ export abstract class RandomGenerator {
 		return [n1, n2]
 	}
 
-	selectRandomIndexFromDistribution(distribution: number[]) {
+	selectRandomIndexFromDistribution(distribution: ArrayLike<number>) {
 		const sum = sumVector(distribution)
 
 		const randomTarget = this.getFloatInRange(0, sum)