function pca(X) {
var XT = numeric.transpose(X);
var mean = XT.map(function(row) {return numeric.sum(row) / row.length;});
X = numeric.transpose(XT.map(function(row, i) {return numeric.sub(row, mean[i]);}));
var sigma = numeric.dot(numeric.transpose(X), X);
var svd = numeric.svd(sigma);
return svd;
}
function multivariateGaussianSample(params) {
var mu = params[0];
var cov = params[1];
var xs = mu.map(function() {return gaussianSample([0, 1])});
var svd = numeric.svd(cov);
var scaledV = numeric.transpose(svd.V).map(function(x) {return numeric.mul(numeric.sqrt(svd.S), x)});
xs = numeric.dot(xs, numeric.transpose(scaledV));
return numeric.add(xs, mu);
}
function multivariateGaussianSample(mu, cov) {
var xs = mu.map(function() {return gaussianSample(0, 1);});
var svd = numeric.svd(cov);
var scaledV = numeric.transpose(svd.V).map(function(x) {
return numeric.mul(numeric.sqrt(svd.S), x);
});
xs = numeric.dot(xs, numeric.transpose(scaledV));
return numeric.add(xs, mu);
}
connection.query('SELECT * FROM interviews',function(err,rows,fields) {
if(err) throw err;
for(var i=0; i < rows.length; i++) {
var row = rows[i];
var temp = row.writeup.split(/[^a-zA-Z0-9]+/);
//process words into training
for(var j = 0; j < temp.length; j++) {
var word = temp[j].toLowerCase();
if(word !== "" && words.indexOf(word)==-1) {
words.push(word);
}
}
}
var clonable = [];
for(var i = 0; i < words.length; i++) {
clonable[i] = 0;
}
for(var i = 0; i < rows.length; i++) {
var training = _.clone(clonable);
var row = rows[i];
var rowwords = row.writeup.split(/[^a-zA-Z0-9]+/);
for(var a = 0; a < rowwords.length; a++) {
training[words.indexOf(rowwords[a])]++;
}
overalltraining.push(training);
scores.push([row.r5-3]);
}
var X = (overalltraining);
var Y = scores;
var beta = numeric.dot(numeric.dot(numeric.inv(numeric.dot(numeric.transpose(X),X)),numeric.transpose(X)),Y);
//console.log(JSON.stringify(beta));
//console.log(JSON.stringify(words));
var newX = clonable;
for(var word in counts) {
var index = words.indexOf(word);
if(index > -1) {
newX[index] = counts[word];
}
}
var rtn = Math.round(numeric.dot(newX,beta)[0]+3);
if(rtn > 5) rtn = 5;
if(rtn < 1) rtn = 1;
res.end(page("<div class=\"alert alert-danger\"><strong>Success!</strong> Your interview predicted rating is: " + rtn + "<br/><br/>Text: " + req.body.writeup + "</div>"));
});
ElasticNetsMarriage.prototype.findPairsRev = function() {
var _ = require('underscore'),
numeric = require('numeric'),
// Each neuron should be associated.
distances = numeric.transpose(this.getRealDistances()),
result = [],
result_index_i = [],
result_index_j = [],
assigned = [];
_.each(distances, function(value_1, i) {
var min_distance = 99999;
var min_j = -1;
_.each(value_1, function(value_2, j) {
if (value_2 < min_distance && !_.contains(assigned, j)) {
min_distance = value_2;
min_j = j;
}
});
// if (!_.contains(assigned, min_j)
result.push([i + 1, min_j + 1]);
result_index_i[i] = min_j;
result_index_j[min_j] = i;
assigned.push(min_j);
});
return {
'index_i': result_index_i,
'index_j': result_index_j,
'result': result
};
};
var forwardSHT = function (N, data, CART_OR_SPH, DIRECT_OR_PINV) {
var Ndirs = data.length, Nsh = (N+1)*(N+1);
var invY_N;
var mag = [,];
if (Nsh>Ndirs) {
console.log("The SHT degree is too high for the number of data points")
}
// Convert cartesian to spherical if needed
if (CART_OR_SPH==0) data = convertCart2Sph(data);
for (var i=0; i<data.length; i++) {
mag[i] = data[i][2];
}
// SH sampling matrix
Y_N = computeRealSH(N, data);
// Direct SHT
if (DIRECT_OR_PINV==0) {
invY_N = numeric.mul(1/Ndirs,Y_N);
}
else {
invY_N = pinv_direct(numeric.transpose(Y_N));
}
// Perform SHT
var coeffs = numeric.dotMV(invY_N, mag);
return coeffs;
}
var pinv_svd = function (A) {
var z = numeric.svd(A), foo = z.S[0];
var U = z.U, S = z.S, V = z.V;
var m = A.length, n = A[0].length, tol = Math.max(m,n)*numeric.epsilon*foo,M = S.length;
var Sinv = new Array(M);
for(var i=M-1;i!==-1;i--) { if(S[i]>tol) Sinv[i] = 1/S[i]; else Sinv[i] = 0; }
return numeric.dot(numeric.dot(V,numeric.diag(Sinv)),numeric.transpose(U))
}
var reduceDatasetDimension = function(dataset, minimumVarianceRetained){
if (dataset.length === 0){
throw 'nodesvm#reduceDatasetDimension :: Invalid datatset';
}
if (typeof minimumVarianceRetained === 'undefined'){
minimumVarianceRetained = 0.99;
}
var inputs = _.map(dataset, function(ex){ return ex[0]; });
var covMatrix = numeric.dot(numeric.transpose(inputs),inputs);
covMatrix = numeric.mul(covMatrix, numeric.rep(numeric.dim(covMatrix), 1 / inputs.length));
var usv = numeric.svd(covMatrix);
var getFirstColumns = function(matrix, nbColumns){
return _.map(matrix, function(line) {
var newLine = [];
for (var i = 0; i < nbColumns; i++){
newLine.push(line[i]);
}
return newLine;
});
};
var n = inputs[0].length,
k = inputs[0].length,
j = 0, retain = 1;
while (true){
// decrease k while retain variance is acceptable
var num = 0;
var den = 0;
for (j = 0; j<n; j++){
if (j < k){
num += usv.S[j];
}
den += usv.S[j];
}
var newRetain = num / den;
if (newRetain < minimumVarianceRetained || k === 0){
k++;
break;
}
retain = newRetain;
k--;
}
var reducedU = getFirstColumns(usv.U, k);
// compute new dataset
var newDataset = _.map(dataset, function(ex){
var input = reduceInputDimension(ex[0], reducedU);
return [input, ex[1]];
});
return {
U: reducedU,
oldDimension: n,
newDimension: k,
dataset: newDataset,
retainedVariance: retain
};
};
return function(x) {
var xx = x;
if (!(x instanceof Array)) {
xx = [x];
}
var dx = numeric.sub(xx, mu);
var v = numeric.dot(numeric.dot(numeric.transpose([dx]), Sinv), [dx]);
return A * Math.exp(-0.5 * v[0][0]);
}
export default function train(data, isTransformed) {
let X = data.map((d) => {
return [1, ...d.slice(0, -1)];
});
let Y = data.map((d) => {
return d[d.length - 1];
});
let wDagger = dot(inv(dot(transpose(X), X)), transpose(X));
let w = dot(wDagger, Y);
let errRate = NaN;
if (!isTransformed) {
errRate = countErrorRate(data, w);
}
return {
w,
errRate
};
};
const Distribution = (n, mean, cov, { u, s, v }) => {
return {
sample() {
// From numpy (paraphrased):
// x = standard_normal(n)
// x = np.dot(x, np.sqrt(s)[:, None] * v)
// x += mean
//
// https://github.com/numpy/numpy/blob/a835270d718d299535606d7104fd86d9b2aa68a6/numpy/random/mtrand/mtrand.pyx
// np.sqrt(s)[:, None] * v
//
// This is an elegant way in numpy to multiply each column of
// v by sqrt(s). Unfortunately, we don't have numpy, so we do this
// manually
const sqrtS = s.map(Math.sqrt);
const scaledV = v.map(row => {
return row.map((val, colIdx) => {
return val * sqrtS[colIdx];
});
});
// We populate a row vector with a standard normal distribution
// (mean 0, variance 1), and then multiply it with scaledV
const standardNormal = standardNormalVector(n);
// compute the correlated dsitribution based on the covariance
// matrix
const variants = Numeric.dot(standardNormal, Numeric.transpose(scaledV));
// add the mean
return variants.map((variant, idx) => variant + mean[idx]);
},
getMean() {
return mean;
},
setMean(unvalidatedMean) {
const newMean = validateMean(unvalidatedMean, n);
return Distribution(n, newMean, cov, { u, s, v });
},
getCov() {
return cov;
},
setCov(unvalidatedCov) {
const { cov: newCov, svd: newSVD } = validateCovAndGetSVD(unvalidatedCov, n);
return Distribution(n, mean, newCov, newSVD);
},
};
};
function countErrorRate(data, w) {
let X = data.map((d) => {
return [1, ...d.slice(0, -1)];
});
let predictedResult = dot(w, transpose(X)).map((r) => {
return r >= 0 ? 1 : -1;
});
let actualResult = data.map((d) => {
return (d[0] * d[0] + d[1] * d[1] - 0.6) >= 0 ? 1 : -1;
});
let err = actualResult.reduce((acc, next, index) => {
return next === predictedResult[index] ? acc : acc + 1;
}, 0);
return err / data.length;
};
function calcAtomGaussians(sigma,step,weigths,px,py)
{
var x = num.linspace(0,1,51); // default step 0.02 => 51 points
var v = [];
var slen = x.length;
var X = num.rep([slen,],x);
var Y = num.transpose(X); // meshgrid square grid X=Y';
var Z = num.rep([slen,slen],0);
for (j=0;j<px.length;j=j+1){
if (Math.abs(weigths[j])>0){
v = bivariate_normal(X,Y,sigma/10,px[j],py[j]); // rescale also the sigma value... caution
console.log("vsum:",num.sum(v));
Z = num.add(Z,num.mul(v,weigths[j]));
console.log("Zsum:",num.sum(Z));
}
}
return {X,Y,Z};
}
return function(v_data){
var t_key = v_parameters.key, t_size = v_parameters.size;
var t_keySize = v_data.length;
var t_data = t_sort(v_data, t_key), t_subData = _.map(t_data, "indexs");
var t_min = t_data[0][t_key], t_max = t_data[t_data.length - 1][t_key];
var t_subMax = _.max(_.max(t_subData, function(t){return _.max(t);}));
var t_subMin = _.min(_.min(t_subData, function(t){return _.min(t);}));
if(t_keySize < t_size[0]){
t_size[0] = t_keySize;
}
var t_binR = (t_max - t_min) / t_size[0], t_subBinR = (t_subMax - t_subMin) / t_size[1];
var t_aggCount = [];
for(var i = 0; i < t_size[0]; i++){
var tt_bin = [];
for(var j = 0; j < t_size[1]; j++){
tt_bin[j] = 0;
}
t_aggCount.push(tt_bin);
}
for(var i = 0; i < t_data.length; i++){
var tt_i = parseInt((t_data[i][t_key] - t_min) / t_binR);
if(tt_i >= t_size[0]){
tt_i = t_size[0] - 1;
}
var tt_sub = t_subData[i];
for(var j = 0; j < tt_sub.length; j++){
var tt_j = parseInt((tt_sub[j] - t_subMin) / t_subBinR);
if(tt_j >= t_size[1]){
tt_j = t_size[1] - 1;
}
t_aggCount[tt_i][tt_j]++
}
}
t_aggCount = numeric.transpose(t_aggCount);
var t_result = {
"attr": v_parameters.attr,
"subattr": v_parameters.subattr,
"size": [t_size[1], t_size[0]],
"aggCount": t_aggCount,
"range": [t_min, t_max],
"subRange": [t_subMin, t_subMax],
};
v_callback(t_result);
};
ElasticNetsMarriage.prototype.relaxPriorities = function(pair_data, power1, power2) {
var numeric = require('numeric'), i,j ;
i = pair_data['i'];
j = pair_data['j'];
console.log('Modifying:', i, j);
this.relaxPair(i, j);
console.log('New priorities:', this.priority1_grouped[i][j], this.priority2_grouped[j][i]);
i = pair_data.better_j_pair[0];
j = pair_data.better_j_pair[1];
console.log('Modifying:', i, j);
this.relaxPair(i, j);
console.log('New priorities:', this.priority1_grouped[i][j], this.priority2_grouped[j][i]);
this.power1.priorities_grouped = this.priority1_grouped;
this.power2.priorities_rev_grouped = numeric.transpose(this.priority2_grouped);
this.resetAlgorithm();
};
function bindSVD(U, S, V) {
var Ut = numeric.transpose(U);
U = null;
function resolveTransform(t) {
var c = centroid(t),
result, i;
// Make c a homogenous coordinate
c.push(1);
// Join the points into a single homogeneous row vector
for (i = 0; i < t.length; i += 1) {
Array.prototype.push.apply(c, t[i]);
c.push(1);
}
result = numeric.dot(Ut, c);
for (i = 0; i < 16; i += 1) {
if (S[i] === 0) {
result[i] = 0;
} else {
result[i] /= S[i];
}
}
result = numeric.dot(V, result);
return [
result.slice(0, 4),
result.slice(4, 8),
result.slice(8, 12),
[0, 0, 0, 1]
];
}
return resolveTransform;
}
Q.when(tt_df.promise, function(v_data){
t0_length = v_data.length;
t_df0.resolve();
if(t0_length == 0){
t_dt = [];
t_layout = null;
}else{
if(t_zooming){
t_dt = _.map(_.sample(v_data, t_sampleLength), function(vv_d){
var tt_d = {};
tt_d['timeDate'] = vv_d['timeDate'];
tt_d['freq'] = vv_d['freq'];
tt_d['baud'] = vv_d['baud'];
if(vv_d['scope']){
tt_d['scope'] = vv_d['scope']
}
if(vv_d['dbm']){
tt_d['dbm'] = vv_d['dbm']
}
if(vv_d['carriernoise']){
tt_d['carriernoise'] = vv_d['carriernoise'];
}
if(vv_d['snr']){
tt_d['snr'] = vv_d['snr'];
}
return tt_d;});
}
if(t_hd){
var t_array = [];
for(var i in v_dimensions){
var tt_name = v_dimensions[i];
t_array.push(_.map(v_data, tt_name));
}
t_array = numeric.transpose(t_array);
t_layout = MDS.getCoordinates(t_array);
t_layout = numeric.dot(t_array, t_layout);
t_layout = _.sample(t_layout, t_sampleLength);
}
}
});
], function(v_data){
var tt_bins = v_conditions.pixS;
for(var i = 0; i < tt_bins[0]; i++){
var tt_bin = [];
for(var j = 0; j < tt_bins[1]; j++){
tt_bin[j] = 0;
}
t_pixelmap.push(tt_bin);
}
var t_fr = v_conditions.freR,
t_tr = v_conditions.timeR;
var t_binR = (t_fr[1] - t_fr[0]) / tt_bins[0],
t_subBinR = (t_tr[1] - t_tr[0]) / tt_bins[1];
var t_data = t_sort(v_data, "_id"), t_subData = _.map(t_data, "indexs");
var t_subMax = _.max(_.max(t_subData, function(t){return _.max(t);}));
var t_subMin = _.min(_.min(t_subData, function(t){return _.min(t);}));
t_ranges['freq'] = [t_data[0]['_id'], t_data[t_data.length - 1]['_id']];
t_ranges['timeDate'] = [t_subMin, t_subMax];
for(var i = 0; i < t_data.length; i++){
var tt_i = parseInt((t_data[i]["_id"] - t_fr[0]) / t_binR);
if(tt_i >= tt_bins[0]){
tt_i = tt_bins[0] - 1;
}
var tt_sub = t_subData[i];
for(var j = 0; j < tt_sub.length; j++){
var tt_j = parseInt((tt_sub[j] - t_tr[0]) / t_subBinR);
if(tt_j >= tt_bins[1]){
tt_j = tt_bins[1] - 1;
}
t_pixelmap[tt_i][tt_j]++;
}
}
t_pixelmap = numeric.transpose(t_pixelmap);
var t_time3_end = new Date().getTime();
console.log("Views[pixelmap]: "+ (t_time3_end - t_time3_start)+"ms");
t_df1.resolve();
});
var pinv_direct = function (A) {
var AT = numeric.transpose(A);
return numeric.dot(numeric.inv(numeric.dot(AT,A)),AT);
}
this.track = function(element, box) {
var scaling, translateX, translateY, rotation;
var croppedPatches = [];
var ptch, px, py;
if (first) {
// do viola-jones on canvas to get initial guess, if we don't have any points
var gi = getInitialPosition(element, box);
if (!gi) {
// send an event on no face found
var evt = document.createEvent("Event");
evt.initEvent("clmtrackrNotFound", true, true);
document.dispatchEvent(evt)
return false;
}
scaling = gi[0];
rotation = gi[1];
translateX = gi[2];
translateY = gi[3];
first = false;
} else {
facecheck_count += 1;
if (params.constantVelocity) {
// calculate where to get patches via constant velocity prediction
if (previousParameters.length >= 2) {
for (var i = 0;i < currentParameters.length;i++) {
currentParameters[i] = (relaxation)*previousParameters[1][i] + (1-relaxation)*((2*previousParameters[1][i]) - previousParameters[0][i]);
//currentParameters[i] = (3*previousParameters[2][i]) - (3*previousParameters[1][i]) + previousParameters[0][i];
}
}
}
// change translation, rotation and scale parameters
rotation = halfPI - Math.atan((currentParameters[0]+1)/currentParameters[1]);
if (rotation > halfPI) {
rotation -= Math.PI;
}
scaling = currentParameters[1] / Math.sin(rotation);
translateX = currentParameters[2];
translateY = currentParameters[3];
}
// copy canvas to a new dirty canvas
sketchCC.save();
// clear canvas
sketchCC.clearRect(0, 0, sketchW, sketchH);
sketchCC.scale(1/scaling, 1/scaling);
sketchCC.rotate(-rotation);
sketchCC.translate(-translateX, -translateY);
sketchCC.drawImage(element, 0, 0, element.width, element.height);
sketchCC.restore();
// get cropped images around new points based on model parameters (not scaled and translated)
var patchPositions = calculatePositions(currentParameters, false);
// check whether tracking is ok
if (scoringWeights && (facecheck_count % 10 == 0)) {
if (!checkTracking()) {
// reset all parameters
first = true;
scoringHistory = [];
for (var i = 0;i < currentParameters.length;i++) {
currentParameters[i] = 0;
previousParameters = [];
}
// send event to signal that tracking was lost
var evt = document.createEvent("Event");
evt.initEvent("clmtrackrLost", true, true);
document.dispatchEvent(evt)
return false;
}
}
var pdata, pmatrix, grayscaleColor;
for (var i = 0; i < numPatches; i++) {
px = patchPositions[i][0]-(pw/2);
py = patchPositions[i][1]-(pl/2);
ptch = sketchCC.getImageData(Math.round(px), Math.round(py), pw, pl);
pdata = ptch.data;
// convert to grayscale
pmatrix = patches[i];
for (var j = 0;j < pdataLength;j++) {
grayscaleColor = pdata[j*4]*0.3 + pdata[(j*4)+1]*0.59 + pdata[(j*4)+2]*0.11;
pmatrix[j] = grayscaleColor;
}
}
/*print weights*/
/*sketchCC.clearRect(0, 0, sketchW, sketchH);
var nuWeights;
for (var i = 0;i < numPatches;i++) {
nuWeights = weights[i].map(function(x) {return x*2000+127;});
drawData(sketchCC, nuWeights, patchSize, patchSize, false, patchPositions[i][0]-(patchSize/2), patchPositions[i][1]-(patchSize/2));
}*/
// print patches
/*sketchCC.clearRect(0, 0, sketchW, sketchH);
for (var i = 0;i < numPatches;i++) {
if ([27,32,44,50].indexOf(i) > -1) {
drawData(sketchCC, patches[i], pw, pl, false, patchPositions[i][0]-(pw/2), patchPositions[i][1]-(pl/2));
}
}*/
if (patchType == "SVM") {
if (typeof(webglFi) !== "undefined") {
responses = getWebGLResponses(patches);
} else if (typeof(svmFi) !== "undefined"){
responses = svmFi.getResponses(patches);
} else {
throw "SVM-filters do not seem to be initiated properly."
}
} else if (patchType == "MOSSE") {
responses = mosseCalc.getResponses(patches);
}
// option to increase sharpness of responses
if (params.sharpenResponse) {
for (var i = 0;i < numPatches;i++) {
for (var j = 0;j < responses[i].length;j++) {
responses[i][j] = Math.pow(responses[i][j], params.sharpenResponse);
}
}
}
// print responses
/*sketchCC.clearRect(0, 0, sketchW, sketchH);
var nuWeights;
for (var i = 0;i < numPatches;i++) {
nuWeights = [];
for (var j = 0;j < responses[i].length;j++) {
nuWeights.push(responses[i][j]*255);
}
//if ([27,32,44,50].indexOf(i) > -1) {
// drawData(sketchCC, nuWeights, searchWindow, searchWindow, false, patchPositions[i][0]-((searchWindow-1)/2), patchPositions[i][1]-((searchWindow-1)/2));
//}
drawData(sketchCC, nuWeights, searchWindow, searchWindow, false, patchPositions[i][0]-((searchWindow-1)/2), patchPositions[i][1]-((searchWindow-1)/2));
}*/
// iterate until convergence or max 10, 20 iterations?:
var originalPositions = currentPositions;
var jac;
var meanshiftVectors = [];
for (var i = 0; i < varianceSeq.length; i++) {
// calculate jacobian
jac = createJacobian(currentParameters, eigenVectors);
// for debugging
//var debugMVs = [];
//
var opj0, opj1;
for (var j = 0;j < numPatches;j++) {
opj0 = originalPositions[j][0]-((searchWindow-1)*scaling/2);
opj1 = originalPositions[j][1]-((searchWindow-1)*scaling/2);
// calculate PI x gaussians
var vpsum = gpopt(searchWindow, currentPositions[j], updatePosition, vecProbs, responses, opj0, opj1, j, varianceSeq[i], scaling);
// calculate meanshift-vector
gpopt2(searchWindow, vecpos, updatePosition, vecProbs, vpsum, opj0, opj1, scaling);
// for debugging
//var debugMatrixMV = gpopt2(searchWindow, vecpos, updatePosition, vecProbs, vpsum, opj0, opj1);
// evaluate here whether to increase/decrease stepSize
/*if (vpsum >= prevCostFunc[j]) {
learningRate[j] *= stepParameter;
} else {
learningRate[j] = 1.0;
}
prevCostFunc[j] = vpsum;*/
// compute mean shift vectors
// extrapolate meanshiftvectors
/*var msv = [];
msv[0] = learningRate[j]*(vecpos[0] - currentPositions[j][0]);
msv[1] = learningRate[j]*(vecpos[1] - currentPositions[j][1]);
meanshiftVectors[j] = msv;*/
meanshiftVectors[j] = [vecpos[0] - currentPositions[j][0], vecpos[1] - currentPositions[j][1]];
//if (isNaN(msv[0]) || isNaN(msv[1])) debugger;
//for debugging
//debugMVs[j] = debugMatrixMV;
//
}
// draw meanshiftVector
/*sketchCC.clearRect(0, 0, sketchW, sketchH);
var nuWeights;
for (var npidx = 0;npidx < numPatches;npidx++) {
nuWeights = debugMVs[npidx].map(function(x) {return x*255*500;});
drawData(sketchCC, nuWeights, searchWindow, searchWindow, false, patchPositions[npidx][0]-((searchWindow-1)/2), patchPositions[npidx][1]-((searchWindow-1)/2));
}*/
var meanShiftVector = numeric.rep([numPatches*2, 1],0.0);
for (var k = 0;k < numPatches;k++) {
meanShiftVector[k*2][0] = meanshiftVectors[k][0];
meanShiftVector[(k*2)+1][0] = meanshiftVectors[k][1];
}
// compute pdm parameter update
//var prior = numeric.mul(gaussianPD, PDMVariance);
var prior = numeric.mul(gaussianPD, varianceSeq[i]);
if (params.weightPoints) {
var jtj = numeric.dot(numeric.transpose(jac), numeric.dot(pointWeights, jac));
} else {
var jtj = numeric.dot(numeric.transpose(jac), jac);
}
var cpMatrix = numeric.rep([numParameters+4, 1],0.0);
for (var l = 0;l < (numParameters+4);l++) {
cpMatrix[l][0] = currentParameters[l];
}
var priorP = numeric.dot(prior, cpMatrix);
if (params.weightPoints) {
var jtv = numeric.dot(numeric.transpose(jac), numeric.dot(pointWeights, meanShiftVector));
} else {
var jtv = numeric.dot(numeric.transpose(jac), meanShiftVector);
}
var paramUpdateLeft = numeric.add(prior, jtj);
var paramUpdateRight = numeric.sub(priorP, jtv);
var paramUpdate = numeric.dot(numeric.inv(paramUpdateLeft), paramUpdateRight);
//var paramUpdate = numeric.solve(paramUpdateLeft, paramUpdateRight, true);
var oldPositions = currentPositions;
// update estimated parameters
for (var k = 0;k < numParameters+4;k++) {
currentParameters[k] -= paramUpdate[k];
}
// clipping of parameters if they're too high
var clip;
for (var k = 0;k < numParameters;k++) {
clip = Math.abs(3*Math.sqrt(eigenValues[k]));
if (Math.abs(currentParameters[k+4]) > clip) {
if (currentParameters[k+4] > 0) {
currentParameters[k+4] = clip;
} else {
currentParameters[k+4] = -clip;
}
}
}
// update current coordinates
currentPositions = calculatePositions(currentParameters, true);
// check if converged
// calculate norm of parameterdifference
var positionNorm = 0;
var pnsq_x, pnsq_y;
for (var k = 0;k < currentPositions.length;k++) {
pnsq_x = (currentPositions[k][0]-oldPositions[k][0]);
pnsq_y = (currentPositions[k][1]-oldPositions[k][1]);
positionNorm += ((pnsq_x*pnsq_x) + (pnsq_y*pnsq_y));
}
//console.log("positionnorm:"+positionNorm);
// if norm < limit, then break
if (positionNorm < convergenceLimit) {
break;
}
}
if (params.constantVelocity) {
// add current parameter to array of previous parameters
previousParameters.push(currentParameters.slice());
previousParameters.splice(0, previousParameters.length == 3 ? 1 : 0);
}
// store positions, for checking convergence
previousPositions.splice(0, previousPositions.length == 10 ? 1 : 0);
previousPositions.push(currentPositions.slice(0));
// send an event on each iteration
var evt = document.createEvent("Event");
evt.initEvent("clmtrackrIteration", true, true);
document.dispatchEvent(evt)
if (this.getConvergence() < 0.5) {
// we must get a score before we can say we've converged
if (scoringHistory.length >= 5) {
if (params.stopOnConvergence) {
this.stop();
}
var evt = document.createEvent("Event");
evt.initEvent("clmtrackrConverged", true, true);
document.dispatchEvent(evt)
}
}
// return new points
return currentPositions;
}
var matrixTrans = bench(function() {
numeric.transpose(A);
});
// calculate the local r squred and t value for averageBetaVector)
const rSquaredLocal = regression.rSquared(biasedX, y, currW);
const tValueLocal = regression.tValue(biasedX, y, currW);
/* eslint-disable new-cap */
const tdist = distributions.Studentt(localCount - betaVector.length);
/* eslint-enable new-cap */
const tcdf = tValueLocal.map(r => tdist.cdf(Math.abs(r)));
const pValueLocal = n.mul(2, n.sub(1, tcdf));
// calculate sseLocal and sstLocal
const sseLocal = n.sum(n.pow(n.sub(y, n.dot(biasedX, currW)), 2));
const sstLocal = n.sum(n.pow(n.sub(y, n.rep(n.dim(y), globalMeanY)), 2));
// calculate varXLocalMatrix
const varXLocalMatrix = n.dot(n.transpose(biasedX), biasedX);
/* eslint-disable no-console */
console.log('local r squared for currW', rSquaredLocal);
console.log('local t Values for currW', tValueLocal);
console.log('local p Values for currW', pValueLocal);
/* eslint-enable no-console */
return {
betaVector,
sseLocal,
sstLocal,
varXLocalMatrix,
currW,
localCount,
rSquared,
this.track = function(element, box) {
emitEvent('clmtrackrBeforeTrack');
var scaling, translateX, translateY, rotation;
var ptch, px, py;
if (first) {
if (!detectingFace) {
detectingFace = true;
// this returns a Promise
faceDetector.getInitialPosition(box)
.then(function (result) {
scaling = result[0];
rotation = result[1];
translateX = result[2];
translateY = result[3];
currentParameters[0] = (scaling*Math.cos(rotation))-1;
currentParameters[1] = (scaling*Math.sin(rotation));
currentParameters[2] = translateX;
currentParameters[3] = translateY;
currentPositions = calculatePositions(currentParameters, true);
first = false;
detectingFace = false;
})
.catch(function (error) {
// send an event on no face found
emitEvent('clmtrackrNotFound');
detectingFace = false;
});
}
return false;
} else {
facecheck_count += 1;
if (params.constantVelocity) {
// calculate where to get patches via constant velocity prediction
if (previousParameters.length >= 2) {
for (var i = 0;i < currentParameters.length;i++) {
currentParameters[i] = (relaxation)*previousParameters[1][i] + (1-relaxation)*((2*previousParameters[1][i]) - previousParameters[0][i]);
//currentParameters[i] = (3*previousParameters[2][i]) - (3*previousParameters[1][i]) + previousParameters[0][i];
}
}
}
// change translation, rotation and scale parameters
rotation = halfPI - Math.atan((currentParameters[0]+1)/currentParameters[1]);
if (rotation > halfPI) {
rotation -= Math.PI;
}
scaling = currentParameters[1] / Math.sin(rotation);
translateX = currentParameters[2];
translateY = currentParameters[3];
}
// copy canvas to a new dirty canvas
sketchCC.save();
// clear canvas
sketchCC.clearRect(0, 0, sketchW, sketchH);
sketchCC.scale(1/scaling, 1/scaling);
sketchCC.rotate(-rotation);
sketchCC.translate(-translateX, -translateY);
sketchCC.drawImage(element, 0, 0, element.width, element.height);
sketchCC.restore();
// get cropped images around new points based on model parameters (not scaled and translated)
var patchPositions = calculatePositions(currentParameters, false);
// check whether tracking is ok
if (scoringWeights && (facecheck_count % 10 == 0)) {
if (!checkTracking()) {
// reset all parameters
resetParameters();
// send event to signal that tracking was lost
emitEvent('clmtrackrLost');
return false;
}
}
var pdata, pmatrix, grayscaleColor;
for (var i = 0; i < numPatches; i++) {
px = patchPositions[i][0]-(pw/2);
py = patchPositions[i][1]-(pl/2);
ptch = sketchCC.getImageData(Math.round(px), Math.round(py), pw, pl);
pdata = ptch.data;
// convert to grayscale
pmatrix = patches[i];
for (var j = 0;j < pdataLength;j++) {
grayscaleColor = pdata[j*4]*0.3 + pdata[(j*4)+1]*0.59 + pdata[(j*4)+2]*0.11;
pmatrix[j] = grayscaleColor;
}
}
// draw weights for debugging
//drawPatches(sketchCC, weights, patchSize, patchPositions, function(x) {return x*2000+127});
// draw patches for debugging
//drawPatches(sketchCC, patches, pw, patchPositions, false, [27,32,44,50]);
if (patchType == 'SVM') {
if (typeof(webglFi) !== 'undefined') {
responses = getWebGLResponses(patches);
} else if (typeof(svmFi) !== 'undefined') {
responses = svmFi.getResponses(patches);
} else {
throw new Error('SVM-filters do not seem to be initiated properly.');
}
} else if (patchType == 'MOSSE') {
responses = mosseCalc.getResponses(patches);
}
// option to increase sharpness of responses
if (params.sharpenResponse) {
for (var i = 0;i < numPatches;i++) {
for (var j = 0;j < responses[i].length;j++) {
responses[i][j] = Math.pow(responses[i][j], params.sharpenResponse);
}
}
}
// draw responses for debugging
//drawPatches(sketchCC, responses, searchWindow, patchPositions, function(x) {return x*255});
// iterate until convergence or max 10, 20 iterations?:
var originalPositions = currentPositions;
var jac;
var meanshiftVectors = [];
for (var i = 0; i < varianceSeq.length; i++) {
// calculate jacobian
jac = createJacobian(currentParameters, eigenVectors);
// for debugging
//var debugMVs = [];
var opj0, opj1;
for (var j = 0;j < numPatches;j++) {
opj0 = originalPositions[j][0]-((searchWindow-1)*scaling/2);
opj1 = originalPositions[j][1]-((searchWindow-1)*scaling/2);
// calculate PI x gaussians
var vpsum = gpopt(searchWindow, currentPositions[j], updatePosition, vecProbs, responses, opj0, opj1, j, varianceSeq[i], scaling);
// calculate meanshift-vector
gpopt2(searchWindow, vecpos, updatePosition, vecProbs, vpsum, opj0, opj1, scaling);
//var debugMatrixMV = gpopt2(searchWindow, vecpos, updatePosition, vecProbs, vpsum, opj0, opj1);
meanshiftVectors[j] = [vecpos[0] - currentPositions[j][0], vecpos[1] - currentPositions[j][1]];
//debugMVs[j] = debugMatrixMV;
}
// draw meanshiftVector for debugging
//drawPatches(sketchCC, debugMVs, searchWindow, patchPositions, function(x) {return x*255*500});
var meanShiftVector = numeric.rep([numPatches*2, 1],0.0);
for (var k = 0;k < numPatches;k++) {
meanShiftVector[k*2][0] = meanshiftVectors[k][0];
meanShiftVector[(k*2)+1][0] = meanshiftVectors[k][1];
}
// compute pdm parameter update
//var prior = numeric.mul(gaussianPD, PDMVariance);
var prior = numeric.mul(gaussianPD, varianceSeq[i]);
var jtj;
if (params.weightPoints) {
jtj = numeric.dot(numeric.transpose(jac), numeric.dot(pointWeights, jac));
} else {
jtj = numeric.dot(numeric.transpose(jac), jac);
}
var cpMatrix = numeric.rep([numParameters+4, 1],0.0);
for (var l = 0;l < (numParameters+4);l++) {
cpMatrix[l][0] = currentParameters[l];
}
var priorP = numeric.dot(prior, cpMatrix);
var jtv;
if (params.weightPoints) {
jtv = numeric.dot(numeric.transpose(jac), numeric.dot(pointWeights, meanShiftVector));
} else {
jtv = numeric.dot(numeric.transpose(jac), meanShiftVector);
}
var paramUpdateLeft = numeric.add(prior, jtj);
var paramUpdateRight = numeric.sub(priorP, jtv);
var paramUpdate = numeric.dot(numeric.inv(paramUpdateLeft), paramUpdateRight);
//var paramUpdate = numeric.solve(paramUpdateLeft, paramUpdateRight, true);
var oldPositions = currentPositions;
// update estimated parameters
for (var k = 0;k < numParameters+4;k++) {
currentParameters[k] -= paramUpdate[k];
}
// clipping of parameters if they're too high
var clip;
for (var k = 0;k < numParameters;k++) {
clip = Math.abs(3*Math.sqrt(eigenValues[k]));
if (Math.abs(currentParameters[k+4]) > clip) {
if (currentParameters[k+4] > 0) {
currentParameters[k+4] = clip;
} else {
currentParameters[k+4] = -clip;
}
}
}
// update current coordinates
currentPositions = calculatePositions(currentParameters, true);
// check if converged
// calculate norm of parameterdifference
var positionNorm = 0;
var pnsq_x, pnsq_y;
for (var k = 0;k < currentPositions.length;k++) {
pnsq_x = (currentPositions[k][0]-oldPositions[k][0]);
pnsq_y = (currentPositions[k][1]-oldPositions[k][1]);
positionNorm += ((pnsq_x*pnsq_x) + (pnsq_y*pnsq_y));
}
// if norm < limit, then break
if (positionNorm < convergenceLimit) {
break;
}
}
if (params.constantVelocity) {
// add current parameter to array of previous parameters
previousParameters.push(currentParameters.slice());
if (previousParameters.length == 3) {
previousParameters.shift();
}
}
// store positions, for checking convergence
if (previousPositions.length == 10) {
previousPositions.shift();
}
previousPositions.push(currentPositions.slice(0));
// send an event on each iteration
emitEvent('clmtrackrIteration');
// we must get a score before we can say we've converged
if (scoringHistory.length >= 5 && this.getConvergence() < convergenceThreshold) {
if (params.stopOnConvergence) {
this.stop();
}
emitEvent('clmtrackrConverged');
}
// return new points
return currentPositions;
}
ClassificationEvaluator.prototype._trainAndEvaluateSet = function(set) {
var classifier = _.clone(this.classifier);
if (set.trainning.length > 0){
classifier.train(set.trainning);
}
var labels = _.uniq(_.pluck(set.test, 'expected'));
var nb_labels = labels.length;
var nb_examples = set.test.length;
var results = numeric.rep([nb_labels,nb_labels],0);
var onces = numeric.rep([nb_labels,1],1);
var getIndex = function(label){
var index = _.indexOf(labels, label);
if (index === -1){ //label existing in trainning set but not in test set
labels.push(label);
index = nb_labels;
_.range(nb_labels).forEach(function(i){
results[i][index] = 0;
});
nb_labels++;
results[index] = numeric.rep([1,nb_labels],0);
}
return index;
};
set.test.forEach(function(example){
var prediction = classifier.predict(example.state);
results[getIndex(prediction)][getIndex(example.expected)] += 1;
});
var sum_predictions = numeric.dot(results, onces);
var sum_expected = numeric.dot(numeric.transpose(results) , onces);
var per_class_reports = [];
var nb_good_prediction = 0;
var self = this;
labels.forEach(function (label) {
var label_index = getIndex(label);
var TP = results[label_index][label_index];
var precision = 0;
var recall = 0;
if (TP !== 0){
precision = TP / sum_predictions[label_index];
recall = TP / sum_expected[label_index];
}
nb_good_prediction+=TP;
var classResult = {
class: label,
precision: precision,
recall: recall,
fscore: self._computeFScore(precision, recall)
};
per_class_reports.push(classResult);
});
var classReports = {};
per_class_reports.forEach(function (r) {
classReports[r.class] = {
precision: r.precision,
recall: r.recall,
fscore: r.fscore
};
});
return {
accuracy: nb_good_prediction / nb_examples,
lowestFscore: _.min(_.pluck(per_class_reports, 'fscore')),
lowestPrecision: _.min(_.pluck(per_class_reports, 'precision')),
lowestRecall: _.min(_.pluck(per_class_reports, 'recall')),
classReports: classReports
};
};
function updateLambda(node){
var nodeName = node.name;
var nodeBeliefMatrix =beliefMatrix[nodeName];
var updatedLambdaVector = nodeBeliefMatrix.lambda_x;
var parents = [];
for(i = 0; i < edges.length; i++){
var possibleNodeName= edges[i].from;
for(j = 0; j<nodes.length; j++){
if(nodes[j].name ===possibleNodeName){
parents.push(nodes[j]);
}
}
}
parents.shift();
var parentsLength = parents.length;
var priorVector = [];
for (var key in node.probabilityMatrix) {
for (var secondKey in node.probabilityMatrix[key]){
priorVector.push(node.probabilityMatrix[key][secondKey]);
}
}
var total = [[]];
var priorVectorEvens = [];
var priorVectorOdds = [];
for(i =0; i < priorVector.length; i+=2){
priorVectorEvens.push(priorVector[i]);
priorVectorOdds.push(priorVector[i+1]);
}
total.push(priorVectorEvens);
total.push(priorVectorOdds);
total.shift();
//Just one parent
var parentBeliefMatrix = beliefMatrix[parents[1].name];
var priorBeliefVector = parentBeliefMatrix.pie_x;
for(i =0; i<total.length; i++){
var tmpLength = total[i].length;
console.log(updatedLambdaVector);
var priorVectorEvens = [];
//console.log(total[i]);
var vectorOdds = [];
var vectorEvens = [];
for(j =0; j < tmpLength; j+=2){
vectorEvens.push(total[i][j]);
vectorOdds.push(total[i][j+1]);
}
var evenResult = 0;
for (i =0; i<updatedLambdaVector.length; i++){
for(j=0; j<vectorEvens.length;j++){
for(k = 0;k<priorBeliefVector.length;k++){
//console.log(updatedLambdaVector[i] + " " + vectorEvens[j] + " " + priorBeliefVector[k]);
if(j===k){
evenResult += updatedLambdaVector[i]*vectorEvens[j]*priorBeliefVector[k];
}
}
}
}
var oddResult = 0;
for (i =0; i<updatedLambdaVector.length; i++){
for(j=0; j<vectorEvens.length;j++){
for(k = 0;k<priorBeliefVector.length;k++){
//console.log(updatedLambdaVector[i] + " " + vectorOdds[j] + " " + priorBeliefVector[k]);
if(j===k){
oddResult += updatedLambdaVector[i]*vectorOdds[j]*priorBeliefVector[k];
}
}
}
}
console.log();
var firstResultVector = [evenResult,oddResult];
console.log();
var otherParentBeliefMatrix = beliefMatrix[parents[0].name];
var otherPriorBeliefVector = otherParentBeliefMatrix.pie_x;
//console.log(total);
var first = total[0];
var second = total[1];
var firstHalfOfFirst = [];
var secondHalfOfFirst = [];
var firstHalfOfSecond = [];
var secondHalfOfSecond = [];
for(i = 0; i<2; i++){
firstHalfOfFirst.push(first[i]);
}
for(i = 0; i<2; i++){
secondHalfOfFirst.push(second[i]);
}
for(i = 2; i<4; i++){
firstHalfOfSecond.push(first[i]);
}
for(i = 2; i<4; i++){
secondHalfOfSecond.push(second[i]);
}
var firstHalf = firstHalfOfFirst.concat(secondHalfOfFirst);
var secondHalf = firstHalfOfSecond.concat(secondHalfOfSecond);
var resultVector= [];
var sum1 = 0;
for(i=0;i<updatedLambdaVector.length;i++ ){
for(j=0;j<firstHalf.length; j++){
for(k=0;k<otherPriorBeliefVector.length;k++){
if(j===k){
sum1+=updatedLambdaVector[i]*firstHalf[j]*otherPriorBeliefVector[k];
}
}
}
}
resultVector.push(sum1);
var sum2 = 0;
for(i=0;i<updatedLambdaVector.length;i++ ){
for(j=0;j<secondHalf.length; j++){
for(k=0;k<otherPriorBeliefVector.length;k++){
if(j===k){
sum2+=updatedLambdaVector[i]*secondHalf[j]*otherPriorBeliefVector[k];
}
}
}
}
resultVector.push(sum2);
//updated lambdas
var resultMatrix= [[]];
resultMatrix.push(firstResultVector);
resultMatrix.push(resultVector);
console.log(beliefMatrix);
var tmpBeliefMatrix = {};
for(j= 0; j <nodes.length; j++){
tmpBeliefMatrix[nodes[j].name] = {};
for(i = 0; i < edges.length; i++){
if(nodes[j].name === edges[i].to){
if(nodes[j].name === node.name){
var val = resultMatrix[j];
//console.log("this is my edges froms" + edges[i].from + "with node " + nodes[j].name);
//get conditional probability matrix
tmpBeliefMatrix[nodes[j].name][edges[i].from]={lambda_x:val,pie_x:beliefMatrix[edges[i].from].pie_x};
}
else{
tmpBeliefMatrix[nodes[j].name][edges[i].from]={lambda_x:[1,1],pie_x:beliefMatrix[edges[i].from].pie_x};
}
}
else{
//tmpBeliefMatrix[nodes[j].name] = null;
}
}
}
var normalizingConstant = 1;
//console.log(tmpBeliefMatrix);
//Now we have temporary bleief matrix so we can go back and calculate pie_x values according to
//
//compute alpha
//console.log(beliefMatrix);
//blief = alpha*pie*lambd
var alphaBeliefVector = beliefMatrix[node.name].belief_x;
var alphaBeliefVal = alphaBeliefVector[0];
var alphaPieVector = beliefMatrix[node.name].pie_x;
var alphaPieVal = alphaPieVector[0];
var alphaLambdaVector = beliefMatrix[node.name].lambda_x;
var alphaLambdaVal = alphaLambdaVector[0];
var alpha = alphaBeliefVal/(alphaPieVal*alphaLambdaVal);
console.log('"----------------------"');
//update parentless nodes
for(var key in tmpBeliefMatrix){
if(key === 'Holmes'){
for(var subkey in tmpBeliefMatrix[key] ){
//console.log("WHAT THE ACTUAL F**K ");
//console.log(tmpBeliefMatrix[key]);
tmpBeliefMatrix[key].Raining.lambda_x= firstResultVector;
}
}
}
//not sure how this function should actually work
//this right here needs to be abstracted but it won't be easy
tmpBeliefMatrix['Watson']['Raining'].lambda_x[0]= alpha*tmpBeliefMatrix['Holmes']['Raining'].lambda_x[0]*tmpBeliefMatrix['Holmes']['Raining'].pie_x[0];
tmpBeliefMatrix['Watson']['Raining'].lambda_x[1]= alpha*tmpBeliefMatrix['Holmes']['Raining'].lambda_x[1]*tmpBeliefMatrix['Holmes']['Raining'].pie_x[1];
//finally update Watsons belief value by taking the onditional versus
console.log("---------------------");
var vectorMatrix = [[]];
for(var key in nodes){
if(nodes[key].name === 'Watson'){
console.log(nodes[key].probabilityMatrix);
for(var subkey in nodes[key].probabilityMatrix){
var array= [];
for(var subsubkey in nodes[key].probabilityMatrix[subkey]){
array.push(nodes[key].probabilityMatrix[subkey][subsubkey]);
}
vectorMatrix.push(array);
}
}
}
vectorMatrix.shift();
//final computation is to get the fold of the conditional probabilities and the updated pie
var tmpVect = tmpBeliefMatrix['Watson']['Raining'].lambda_x;
console.log(numeric.transpose(vectorMatrix));
console.log(tmpVect);
var resultVector2 = [];
for(i=0; i < numeric.transpose(vectorMatrix).length; i++){
var tmp1 = 0;
for(j=0; j < numeric.transpose(vectorMatrix)[i].length; j++){
console.log(tmpVect[j] + " " + numeric.transpose(vectorMatrix)[i][j]);
tmp1+=tmpVect[j]*numeric.transpose(vectorMatrix)[i][j];
}
//console.log(tmp1);
resultVector2.push(tmp1);
}
beliefMatrix['Watson'].belief_x = resultVector2;
beliefMatrix['Watson'].pie_x = resultVector2;
beliefMatrix['Raining'].belief_x = tmpVect;
beliefMatrix['Holmes'].belief_x = beliefMatrix['Holmes'].lambda_x;
console.log(beliefMatrix);
}
}
ElasticNets.prototype.updateNeurons = function(diff, weights) {
var numeric = require('numeric'),
_ = require('underscore'),
TSPCommon = require('./TSPCommon');
var diff_grouped = TSPCommon._grouper(diff, diff.length / this.coordinates.length),
diff_grouped_transposed = numeric.transpose(diff_grouped),
weights_transposed = numeric.transpose(weights),
sum, sum1, sum2, part1, part2, part1_1, part1_2, j0, j1, j2, delta = [];
//if (this.k < 0.1 && this.method_params.beta == 2) {
// console.log('activated');
// method_params.beta = 4.5;
//}
for (j0 = 0; j0 < this.neurons.length; j0++) {
//if (this.method_params.beta == 10) {
// console.log('activated');
//}
j1 = (j0 + 1) % this.neurons.length;
j2 = (j0 - 1) % this.neurons.length;
if (j1 < 0) {
j1 = this.neurons.length - j1;
}
if (j2 < 0) {
// + because minus on minus.
j2 = this.neurons.length + j2;
}
part1_1 = numeric.transpose(diff_grouped_transposed[j0]);
part1_2 = weights_transposed[j0];
//part1 = numeric.mul(part1, part2);
part1 = _.map(part1_1, function (value, key) {
return numeric.mul(value, part1_2);
});
part1 = _.map(part1, function (value) {
return numeric.sum(value);
});
part2 = numeric.add(numeric.sub(this.neurons[j1], numeric.mul(this.neurons[j0], 2)), this.neurons[j2]);
sum1 = numeric.mul(part1, this.method_params.alpha);
sum2 = numeric.mul(part2, this.method_params.beta * this.k);
sum = numeric.add(sum1, sum2);
delta.push(sum);
}
for (j0 = 0; j0 < delta.length; j0++) {
// Make sure values are float.
this.neurons[j0] = _.map(this.neurons[j0], function (value) {
return parseFloat(value);
});
delta[j0] = _.map(delta[j0], function (value) {
return parseFloat(value);
});
// Append deltas.
this.neurons[j0] = _.map(this.neurons[j0], function (value, key) {
return value + delta[j0][key];
});
}
};