Top 10 Examples of "ml-matrix in functional component" in JavaScript
Dive into secure and efficient coding practices with our curated list of the top 10 examples showcasing 'ml-matrix' in functional components in JavaScript. Our advanced machine learning engine meticulously scans each line of code, cross-referencing millions of open source libraries to ensure your implementation is not just functional, but also robust and secure. Elevate your React applications to new heights by mastering the art of handling side effects, API calls, and asynchronous operations with confidence and precision.
it('X may be recomputed', function () {
let U = pca.predict(iris);
let V = pca.getLoadings();
let S = pca.getEigenvalues();
// we scale the scores
let SU = U.divRowVector(S);
// we recompute X
let RX = SU.mmul(Matrix.diag(S)).mmul(V);
expect(RX.get(0, 0)).toBeCloseTo(-0.89767388, 6);
});_computeWithNIPALS(dataset, nCompNIPALS) {
this.U = new Matrix(nCompNIPALS, dataset.columns);
this.S = [];
let x = dataset;
for (let i = 0; i < nCompNIPALS; i++) {
let dc = new NIPALS(x);
this.U.setRow(i, dc.w.transpose());
this.S.push(Math.pow(dc.s.get(0, 0), 2));
x = dc.xResidual;
}
this.U = this.U.transpose(); // to be compatible with API
}
}[x2, y2, 1, 0, 0, 0, -x2 * X2, -y2 * X2],
[x3, y3, 1, 0, 0, 0, -x3 * X3, -y1 * X3],
[x4, y4, 1, 0, 0, 0, -x4 * X4, -y4 * X4],
[0, 0, 0, x1, y1, 1, -x1 * Y1, -y1 * Y1],
[0, 0, 0, x2, y2, 1, -x2 * Y2, -y2 * Y2],
[0, 0, 0, x3, y3, 1, -x3 * Y3, -y3 * Y3],
[0, 0, 0, x4, y4, 1, -x4 * Y4, -y4 * Y4]
]);
let D = Matrix.columnVector([X1, X2, X3, X4, Y1, Y2, Y3, Y4]);
let svd = new SingularValueDecomposition(S);
let T = svd.solve(D); // solve S*T = D
let [a, b, c, d, e, f, g, h] = T.to1DArray();
let Xt = new Matrix(heightRect, widthRect);
for (let channel = 0; channel < this.channels; channel++) {
for (let i = 0; i < heightRect; i++) {
for (let j = 0; j < widthRect; j++) {
Xt.set(i, j, projectionPoint(i, j, a, b, c, d, e, f, g, h, this, channel));
}
}
newImage.setMatrix(Xt, { channel: channel });
}
return newImage;
}} else {
widthRect = Math.ceil(Math.max(distance2Points(tl, tr), distance2Points(bl, br)));
heightRect = Math.ceil(Math.max(distance2Points(tl, bl), distance2Points(tr, br)));
}
let newImage = Image.createFrom(this, { width: widthRect, height: heightRect });
let [X1, Y1] = tl;
let [X2, Y2] = tr;
let [X3, Y3] = br;
let [X4, Y4] = bl;
let [x1, y1] = [0, 0];
let [x2, y2] = [0, widthRect - 1];
let [x3, y3] = [heightRect - 1, widthRect - 1];
let [x4, y4] = [heightRect - 1, 0];
let S = new Matrix([
[x1, y1, 1, 0, 0, 0, -x1 * X1, -y1 * X1],
[x2, y2, 1, 0, 0, 0, -x2 * X2, -y2 * X2],
[x3, y3, 1, 0, 0, 0, -x3 * X3, -y1 * X3],
[x4, y4, 1, 0, 0, 0, -x4 * X4, -y4 * X4],
[0, 0, 0, x1, y1, 1, -x1 * Y1, -y1 * Y1],
[0, 0, 0, x2, y2, 1, -x2 * Y2, -y2 * Y2],
[0, 0, 0, x3, y3, 1, -x3 * Y3, -y3 * Y3],
[0, 0, 0, x4, y4, 1, -x4 * Y4, -y4 * Y4]
]);
let D = Matrix.columnVector([X1, X2, X3, X4, Y1, Y2, Y3, Y4]);
let svd = new SingularValueDecomposition(S);
let T = svd.solve(D); // solve S*T = D
let [a, b, c, d, e, f, g, h] = T.to1DArray();function ellipse(width, height, options) {
const matrix = Matrix.zeros(height, width, options);
let yEven = 1 - height % 2;
let xEven = 1 - width % 2;
let a = Math.floor((width - 1) / 2); // horizontal ellipse axe
let b = Math.floor((height - 1) / 2); // vertical ellipse axe
let a2 = a * a;
let b2 = b * b;
if (options.filled) {
for (let y = 0; y <= b; y++) {
let shift = Math.floor(Math.sqrt(a2 - a2 * y * y / b2));
for (let x = a - shift; x <= a; x++) {
matrix.set(b - y, x, 1);
matrix.set(b + y + yEven, x, 1);
matrix.set(b - y, width - x - 1, 1);
matrix.set(b + y + yEven, width - x - 1, 1);
}
}forward(input) {
this.input = input.slice();
this.input.push(1); // bias
var offs = 0; // offset used to get the current weights in the current perceptron
this.output = Matrix.zeros(1, this.output.length).getRow(0);
for (var i = 0; i < this.output.length; ++i) {
for (var j = 0; j < this.input.length; ++j) {
this.output[i] += this.weights[offs + j] * this.input[j];
}
if (this.isSigmoid)
this.output[i] = sigmoid(this.output[i]);
offs += this.input.length;
}
return this.output.slice();
}for (let x = 0; x < cutWidth; x++) {
const wOffset = (x + kernelOffsetX) * channels;
for (let y = 0; y < height; y++) {
columnData[y] = convolvedData[y * cutWidth + x];
}
const result = columnConvolution.convolve(columnData);
for (let i = 0; i < result.length; i++) {
const idx = (i + kernelOffsetY) * hFactor + wOffset + c;
newImage.data[idx] = round(clamp(result[i]));
}
}
}
// Calculate kernel from separated kernels.
const matrixX = Matrix.rowVector(kernelX);
const matrixY = Matrix.columnVector(kernelY);
const kernel = matrixY.mmul(matrixX).to2DArray();
// Apply convolution on the left and right borders
for (let c = 0; c < channels; c++) {
for (let bY = 0; bY < height; bY++) {
for (let bX = 0; bX < kernelOffsetX; bX++) {
const idx = (bY * width + bX) * channels + c;
const bXopp = width - bX - 1;
const bYopp = height - bY - 1;
const idxOpp = (bYopp * width + bXopp) * channels + c;
newImage.data[idx] = computeConvolutionPixel(
bX,
bY,constructor(inputs, outputs, options) {
super();
if (inputs === true) {
// reloading model
this.alpha = outputs.alpha;
this.inputs = outputs.inputs;
this.kernelType = outputs.kernelType;
this.kernelOptions = outputs.kernelOptions;
this.kernel = new Kernel(outputs.kernelType, outputs.kernelOptions);
} else {
inputs = Matrix.checkMatrix(inputs);
options = Object.assign({}, defaultOptions, options);
const kernelFunction = new Kernel(
options.kernelType,
options.kernelOptions
);
const K = kernelFunction.compute(inputs);
const n = inputs.rows;
K.add(Matrix.eye(n, n).mul(options.lambda));
this.alpha = solve(K, outputs);
this.inputs = inputs;
this.kernelType = options.kernelType;
this.kernelOptions = options.kernelOptions;
this.kernel = kernelFunction;
}var selectedFunction = ACTIVATION_FUNCTIONS[options.activation];
var params = selectedFunction.activation.length;
var actFunction = params > 1 ? (val) => selectedFunction.activation(val, options.activationParam) : selectedFunction.activation;
var derFunction = params > 1 ? (val) => selectedFunction.derivate(val, options.activationParam) : selectedFunction.derivate;
this.activationFunction = function (i, j) {
this.set(i, j, actFunction(this.get(i, j)));
};
this.derivate = function (i, j) {
this.set(i, j, derFunction(this.get(i, j)));
};
if (options.model) {
// load model
this.W = Matrix.checkMatrix(options.W);
this.b = Matrix.checkMatrix(options.b);
} else {
// default constructor
this.W = Matrix.rand(this.inputSize, this.outputSize);
this.b = Matrix.zeros(1, this.outputSize);
this.W.apply(function (i, j) {
this.set(i, j, this.get(i, j) / Math.sqrt(options.inputSize));
});
}
}var params = selectedFunction.activation.length;
var actFunction = params > 1 ? (val) => selectedFunction.activation(val, options.activationParam) : selectedFunction.activation;
var derFunction = params > 1 ? (val) => selectedFunction.derivate(val, options.activationParam) : selectedFunction.derivate;
this.activationFunction = function (i, j) {
this.set(i, j, actFunction(this.get(i, j)));
};
this.derivate = function (i, j) {
this.set(i, j, derFunction(this.get(i, j)));
};
if (options.model) {
// load model
this.W = Matrix.checkMatrix(options.W);
this.b = Matrix.checkMatrix(options.b);
} else {
// default constructor
this.W = Matrix.rand(this.inputSize, this.outputSize);
this.b = Matrix.zeros(1, this.outputSize);
this.W.apply(function (i, j) {
this.set(i, j, this.get(i, j) / Math.sqrt(options.inputSize));
});
}
}