bool ModelParametersGMR::saveGMM(string directory, const vector<VectorXd>& centers, const vector<MatrixXd>& covars, int iter)
{
for (size_t i_gau = 0; i_gau < centers.size(); i_gau++)
{
stringstream stream;
stream << "gmm";
if (iter>=0)
stream << "_iter" << setw(2) << setfill('0') << iter;
stream << "_mu" << setw(3) << setfill('0') << i_gau << ".txt";
string filename = stream.str();
if (!saveMatrix(directory, filename, centers[i_gau], true))
return false;
cout << " filename=" << filename << endl;
stringstream stream2;
stream2 << "gmm";
if (iter>=0)
stream2 << "_iter" << setw(2) << setfill('0') << iter;
stream2 << "_covar" << setw(3) << setfill('0') << i_gau << ".txt";
filename = stream2.str();
cout << " filename=" << filename << endl;
if (!saveMatrix(directory, filename, covars[i_gau], true))
return false;
}
return true;
}
bool FunctionApproximatorGPR::saveGridData(const VectorXd& min, const VectorXd& max, const VectorXi& n_samples_per_dim, string save_directory, bool overwrite) const
{
if (save_directory.empty())
return true;
MatrixXd inputs_grid;
FunctionApproximator::generateInputsGrid(min, max, n_samples_per_dim, inputs_grid);
const ModelParametersGPR* model_parameters_gpr = static_cast<const ModelParametersGPR*>(getModelParameters());
MatrixXd activations_grid;
model_parameters_gpr->kernelActivations(inputs_grid, activations_grid);
saveMatrix(save_directory,"n_samples_per_dim.txt",n_samples_per_dim,overwrite);
saveMatrix(save_directory,"inputs_grid.txt",inputs_grid,overwrite);
saveMatrix(save_directory,"activations_grid.txt",activations_grid,overwrite);
// Weight the basis function activations
VectorXd weights = model_parameters_gpr->weights();
for (int b=0; b<activations_grid.cols(); b++)
activations_grid.col(b).array() *= weights(b);
saveMatrix(save_directory,"activations_weighted_grid.txt",activations_grid,overwrite);
// Sum over weighed basis functions
MatrixXd predictions_grid = activations_grid.rowwise().sum();
saveMatrix(save_directory,"predictions_grid.txt",predictions_grid,overwrite);
return true;
}
bool saveToDirectory(const UpdateSummary& summary, string directory, bool overwrite)
{
// Make directory if it doesn't already exist
if (!boost::filesystem::exists(directory))
{
if (!boost::filesystem::create_directories(directory))
{
cerr << __FILE__ << ":" << __LINE__ << ":";
cerr << "Couldn't make directory file '" << directory << "'." << endl;
return false;
}
}
// Abbreviations to make it fit on one line
bool ow = overwrite;
string dir = directory;
VectorXd cost_eval_vec = VectorXd::Constant(1,summary.cost_eval);
if (!saveMatrix(dir, "distribution_mean.txt", summary.distribution->mean(), ow)) return false;
if (!saveMatrix(dir, "distribution_covar.txt", summary.distribution->covar(), ow)) return false;
if (!saveMatrix(dir, "cost_eval.txt", cost_eval_vec, ow)) return false;
if (!saveMatrix(dir, "samples.txt", summary.samples, ow)) return false;
if (!saveMatrix(dir, "costs.txt", summary.costs, ow)) return false;
if (!saveMatrix(dir, "weights.txt", summary.weights, ow)) return false;
if (!saveMatrix(dir, "distribution_new_mean.txt", summary.distribution_new->mean(), ow)) return false;
if (!saveMatrix(dir, "distribution_new_covar.txt", summary.distribution_new->covar(), ow)) return false;
if (summary.cost_vars_eval.size()>0)
if (!saveMatrix(dir, "cost_vars_eval.txt",summary.cost_vars_eval, ow)) return false;
if (summary.cost_vars.size()>0)
if (!saveMatrix(dir, "cost_vars.txt",summary.cost_vars, ow)) return false;
return true;
}
void testSaveMatrix(void) {
FILE *matrixFile = fopen("test/matrix_to_save","wb");
if(matrixFile == NULL) {
return;
}
size_t columns = 3;
size_t rows = 3;
floattype **matrix = AllocMatrix(rows, columns);
floattype **expected = AllocMatrix(rows, columns);
CU_ASSERT(CODE_OK == saveMatrix(matrix, matrixFile, rows, columns));
FreeMatrix(matrix, rows);
fclose(matrixFile);
Matrix *matrixLoaded;
FILE *loadFile = fopen("test/matrix_to_save","rb");
matrixLoaded = loadMatrix(loadFile);
fclose(loadFile);
CU_ASSERT(NULL != matrixLoaded);
if(NULL == matrixLoaded) {
FreeMatrix(expected, rows);
return;
}
CU_ASSERT(3 == matrixLoaded->header.colcount);
CU_ASSERT(3 == matrixLoaded->header.rowcount);
assertMatricesAreSame(expected, matrixLoaded->matrix, &(matrixLoaded->header));
FreeMatrix(matrixLoaded->matrix, matrixLoaded->header.rowcount);
free(matrixLoaded);
FreeMatrix(expected, rows);
}
void F4Reducer::classicReducePolySet(
const std::vector< std::unique_ptr<Poly> >& polys,
const PolyBasis& basis,
std::vector< std::unique_ptr<Poly> >& reducedOut
) {
if (polys.size() <= 1) {
if (tracingLevel >= 2)
std::cerr << "F4Reducer: Using fall-back reducer for "
<< polys.size() << " polynomials.\n";
mFallback->classicReducePolySet(polys, basis, reducedOut);
return;
}
reducedOut.clear();
MATHICGB_ASSERT(!polys.empty());
if (tracingLevel >= 2)
std::cerr << "F4Reducer: Reducing " << polys.size() << " polynomials.\n";
SparseMatrix reduced;
QuadMatrix::Monomials monomials;
{
QuadMatrix qm(ring());
{
if (mType == OldType) {
F4MatrixBuilder builder(basis, mMemoryQuantum);
for (const auto& poly : polys)
builder.addPolynomialToMatrix(*poly);
builder.buildMatrixAndClear(qm);
} else {
F4MatrixBuilder2 builder(basis, mMemoryQuantum);
for (const auto& poly : polys)
builder.addPolynomialToMatrix(*poly);
builder.buildMatrixAndClear(qm);
}
}
MATHICGB_LOG_INCREMENT_BY(F4MatrixRows, qm.rowCount());
MATHICGB_LOG_INCREMENT_BY(F4MatrixTopRows, qm.topLeft.rowCount());
MATHICGB_LOG_INCREMENT_BY(F4MatrixBottomRows, qm.bottomLeft.rowCount());
MATHICGB_LOG_INCREMENT_BY(F4MatrixEntries, qm.entryCount());
saveMatrix(qm);
reduced = F4MatrixReducer(basis.ring().charac()).
reducedRowEchelonFormBottomRight(qm);
monomials = std::move(qm.rightColumnMonomials);
for (auto& mono : qm.leftColumnMonomials)
monoid().freeRaw(mono.castAwayConst());
}
if (tracingLevel >= 2 && false)
std::cerr << "F4Reducer: Extracted " << reduced.rowCount()
<< " non-zero rows\n";
for (SparseMatrix::RowIndex row = 0; row < reduced.rowCount(); ++row) {
auto p = make_unique<Poly>(basis.ring());
reduced.rowToPolynomial(row, monomials, *p);
reducedOut.push_back(std::move(p));
}
for (auto& mono : monomials)
monoid().freeRaw(mono.castAwayConst());
}
int main()
{
double* m1,*m2;
int m1rowCount=0,m1colCount=0,m2rowCount=0,m2colCount=0;
m1=loadMatrix("m1.txt",&m1rowCount,&m1colCount);
m2=loadMatrix("m2.txt",&m2rowCount,&m2colCount);
printf("m1:\n");
printMatrix(m1rowCount,m1colCount,m1);
printf("\nm2:\n");
printMatrix(m2rowCount,m2colCount,m2);
printf("\n");
if(m1colCount==m2rowCount)
{
double* m3 = product(m1rowCount,m1colCount,m2rowCount,m2colCount, m1,m2);
printf("m1*m2:\n");
printMatrix(m1rowCount,m2colCount,m3);
saveMatrix("m3.txt",m1rowCount,m2colCount,m3);
free(m3);
}
else
printf("Nie mozna pomnozyc tych macierzy");
free(m1);
free(m2);
return 0;
}
void SoftmaxLayer::runForwardImplementation(Bundle& bundle)
{
auto& inputActivationsVector = bundle[ "inputActivations"].get<MatrixVector>();
auto& outputActivationsVector = bundle["outputActivations"].get<MatrixVector>();
assert(inputActivationsVector.size() == 1);
auto inputActivations = foldTime(inputActivationsVector.back());
util::log("SoftmaxLayer") << " Running forward propagation of matrix "
<< inputActivations.shapeString() << "\n";
if(util::isLogEnabled("SoftmaxLayer::Detail"))
{
util::log("SoftmaxLayer::Detail") << " input: "
<< inputActivations.debugString();
}
auto outputActivations = softmax(inputActivations);
if(util::isLogEnabled("SoftmaxLayer::Detail"))
{
util::log("SoftmaxLayer::Detail") << " outputs: "
<< outputActivations.debugString();
}
saveMatrix("outputActivations", outputActivations);
outputActivationsVector.push_back(unfoldTime(outputActivations,
inputActivationsVector.front().size()));
}
/**
* @param aXSide LEFT means we draw from the left side of the buffer (which
* is drawn on the right side of mBufferRect). RIGHT means we draw from
* the right side of the buffer (which is drawn on the left side of
* mBufferRect).
* @param aYSide TOP means we draw from the top side of the buffer (which
* is drawn on the bottom side of mBufferRect). BOTTOM means we draw from
* the bottom side of the buffer (which is drawn on the top side of
* mBufferRect).
*/
void
ThebesLayerBuffer::DrawBufferQuadrant(gfxContext* aTarget,
XSide aXSide, YSide aYSide,
float aOpacity,
gfxASurface* aMask,
const gfxMatrix* aMaskTransform)
{
// The rectangle that we're going to fill. Basically we're going to
// render the buffer at mBufferRect + quadrantTranslation to get the
// pixels in the right place, but we're only going to paint within
// mBufferRect
nsIntRect quadrantRect = GetQuadrantRectangle(aXSide, aYSide);
nsIntRect fillRect;
if (!fillRect.IntersectRect(mBufferRect, quadrantRect))
return;
aTarget->NewPath();
aTarget->Rectangle(gfxRect(fillRect.x, fillRect.y,
fillRect.width, fillRect.height),
true);
gfxPoint quadrantTranslation(quadrantRect.x, quadrantRect.y);
nsRefPtr<gfxPattern> pattern = new gfxPattern(mBuffer);
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
gfxPattern::GraphicsFilter filter = gfxPattern::FILTER_NEAREST;
pattern->SetFilter(filter);
#endif
gfxContextMatrixAutoSaveRestore saveMatrix(aTarget);
// Transform from user -> buffer space.
gfxMatrix transform;
transform.Translate(-quadrantTranslation);
pattern->SetMatrix(transform);
aTarget->SetPattern(pattern);
if (aMask) {
if (aOpacity == 1.0) {
aTarget->SetMatrix(*aMaskTransform);
aTarget->Mask(aMask);
} else {
aTarget->PushGroup(gfxASurface::CONTENT_COLOR_ALPHA);
aTarget->Paint(aOpacity);
aTarget->PopGroupToSource();
aTarget->SetMatrix(*aMaskTransform);
aTarget->Mask(aMask);
}
} else {
if (aOpacity == 1.0) {
aTarget->Fill();
} else {
aTarget->Save();
aTarget->Clip();
aTarget->Paint(aOpacity);
aTarget->Restore();
}
}
}
void saveAll(char* filePath, const char* filenameAdditon, double* VecSig, double* VecStr, double* VecDsig, double* VecDstr, double* InvF, double* InvFT, double* G,
double* P11q, double* P22, double* P21, double* T3, double* Fe1q, double* Fe2, double* Fs, size_t nElems, size_t nVertices) {
char path[512];
sprintf(path, "%s%s", filePath, filenameAdditon);
saveVector(VecSig, nElems, 14, path, "sig.sav");
saveVector(VecStr, nElems, 20, path, "str.sav");
saveVector(VecDsig, nElems, 14, path, "Dsig.sav");
saveVector(VecDstr, nElems, 20, path, "Dstr.sav");
saveMatrix(InvF, nElems, 14, 14, 14*14, path, "invF.sav");
saveMatrix(InvFT, nElems, 14, 14, 14*14, path, "invFT.sav");
saveMatrix(G, nElems, 20, 14, 24*14, path, "G.sav");
saveMatrix(P11q, nElems, 14, 14, 14*14, path, "P11q.sav");
saveMatrix(P21, nElems, 6, 14, 6*14, path, "P21.sav");
saveMatrix(P22, nElems, 6, 6, 6*6, path, "P22.sav");
saveMatrixT(T3, nVertices, 3, 2, 3*2, path, "T3.sav");
saveVector(Fe1q, nElems, 14, path, "fe1q.sav");
saveVector(Fe2, nElems, 6, path, "fe2.sav");
saveVector(Fs, nElems, 14, path, "fs.sav");
}
bool saveToDirectory(const vector<UpdateSummaryParallel>& update_summaries, std::string directory, bool overwrite, bool only_learning_curve)
{
// Save the learning curve
int n_updates = update_summaries.size();
assert(n_updates>0);
int n_parallel = update_summaries[0].distributions.size();
MatrixXd learning_curve(n_updates,2+n_parallel);
learning_curve(0,0) = 0; // First evaluation is at 0
for (int i_update=0; i_update<n_updates; i_update++)
{
// Number of samples at which an evaluation was performed.
if (i_update>0)
{
int n_samples = update_summaries[i_update].costs.rows();
learning_curve(i_update,0) = learning_curve(i_update-1,0) + n_samples;
}
// The cost of the evaluation at this update
learning_curve(i_update,1) = update_summaries[i_update].cost_eval;
for (int i_parallel=0; i_parallel<n_parallel; i_parallel++)
{
// The largest eigenvalue of the covariance matrix, for each distribution
DistributionGaussian* distribution = update_summaries[i_update].distributions[i_parallel];
MatrixXd eigen_values = distribution->covar().eigenvalues().real();
learning_curve(i_update,2+i_parallel) = sqrt(eigen_values.maxCoeff());
}
}
if (!saveMatrix(directory, "learning_curve.txt", learning_curve, overwrite))
return false;
if (!only_learning_curve)
{
// Save all the information in the update summaries
for (int i_update=0; i_update<n_updates; i_update++)
{
stringstream stream;
stream << directory << "/update" << setw(5) << setfill('0') << i_update+1 << "/";
if (!saveToDirectory(update_summaries[i_update], stream.str(),overwrite))
return false;
}
}
return true;
}
int main(int argc, char* argv[])
{
int lines, columns, qtd;
printf("linhas: ");
scanf("%d", &lines);
printf("colunas: ");
scanf("%d", &columns);
printf("quantidade: ");
scanf("%d", &qtd);
int i;
for(i = 0; i < qtd; i++)
{
int** matrix = randMatrixGen(lines, columns);
saveMatrix(lines,columns, matrix, i);
}
}
int main()
{
if (pthread_mutex_init(&mutex, nullptr))
{
return -1;
}
if (!gy85.initialize())
{
return -1;
}
if (!timer.initialize())
{
return -1;
}
running = true;
pthread_create(&thread, nullptr, measure, nullptr);
std::cin.get();
if (pthread_mutex_lock(&mutex))
{
return shutdown(-1);
}
glm::vec3 accelerometer;
gy85.getAccelerometer(accelerometer);
glm::vec3 compass;
gy85.getCompass(compass);
glm::mat3 worldToCard;
computeToWorldMatrix(accelerometer, compass, worldToCard);
saveMatrix("rotation.calibration", worldToCard);
pthread_mutex_unlock(&mutex);
return shutdown(0);
}
DrawResult
ClippedImage::DrawSingleTile(gfxContext* aContext,
const nsIntSize& aSize,
const ImageRegion& aRegion,
uint32_t aWhichFrame,
GraphicsFilter aFilter,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags)
{
MOZ_ASSERT(!MustCreateSurface(aContext, aSize, aRegion, aFlags),
"Shouldn't need to create a surface");
gfxRect clip(mClip.x, mClip.y, mClip.width, mClip.height);
nsIntSize size(aSize), innerSize(aSize);
if (NS_SUCCEEDED(InnerImage()->GetWidth(&innerSize.width)) &&
NS_SUCCEEDED(InnerImage()->GetHeight(&innerSize.height))) {
double scaleX = aSize.width / clip.width;
double scaleY = aSize.height / clip.height;
// Map the clip and size to the scale requested by the caller.
clip.Scale(scaleX, scaleY);
size = innerSize;
size.Scale(scaleX, scaleY);
} else {
MOZ_ASSERT(false,
"If ShouldClip() led us to draw then we should never get here");
}
// We restrict our drawing to only the clipping region, and translate so that
// the clipping region is placed at the position the caller expects.
ImageRegion region(aRegion);
region.MoveBy(clip.x, clip.y);
region = region.Intersect(clip);
gfxContextMatrixAutoSaveRestore saveMatrix(aContext);
aContext->Multiply(gfxMatrix::Translation(-clip.x, -clip.y));
return InnerImage()->Draw(aContext, size, region,
aWhichFrame, aFilter,
aSVGContext.map(UnclipViewport,
make_pair(innerSize, mClip.Size())),
aFlags);
}
int main(int argc, char** argv)
{
if(argc != 6) {
printf("Usage: binary <size> <input1_file> <input2_file> <output_file> <coefficient>\n");
return -1;
}
unsigned int size = atoi(argv[1]);
float coef = atof(argv[5]);
float* a = loadMatrix(argv[2], 1, size);
float* b = loadMatrix(argv[3], 1, size);
float* m = (float*) malloc (sizeof(float)*size);
triad(m, a, b, coef, size);
saveMatrix(argv[4], m, 1, size);
free(a);
free(b);
free(m);
systamp();
return 0;
}
DrawResult
RasterImage::DrawInternal(DrawableSurface&& aSurface,
gfxContext* aContext,
const IntSize& aSize,
const ImageRegion& aRegion,
SamplingFilter aSamplingFilter,
uint32_t aFlags,
float aOpacity)
{
gfxContextMatrixAutoSaveRestore saveMatrix(aContext);
ImageRegion region(aRegion);
bool frameIsFinished = aSurface->IsFinished();
// By now we may have a frame with the requested size. If not, we need to
// adjust the drawing parameters accordingly.
IntSize finalSize = aSurface->GetImageSize();
bool couldRedecodeForBetterFrame = false;
if (finalSize != aSize) {
gfx::Size scale(double(aSize.width) / finalSize.width,
double(aSize.height) / finalSize.height);
aContext->Multiply(gfxMatrix::Scaling(scale.width, scale.height));
region.Scale(1.0 / scale.width, 1.0 / scale.height);
couldRedecodeForBetterFrame = CanDownscaleDuringDecode(aSize, aFlags);
}
if (!aSurface->Draw(aContext, region, aSamplingFilter, aFlags, aOpacity)) {
RecoverFromInvalidFrames(aSize, aFlags);
return DrawResult::TEMPORARY_ERROR;
}
if (!frameIsFinished) {
return DrawResult::INCOMPLETE;
}
if (couldRedecodeForBetterFrame) {
return DrawResult::WRONG_SIZE;
}
return DrawResult::SUCCESS;
}
bool UnifiedModel::saveGridData(const VectorXd& min, const VectorXd& max, const VectorXi& n_samples_per_dim, string save_directory, bool overwrite) const
{
if (save_directory.empty())
return true;
#ifndef NDEBUG // Variables below are only required for asserts; check for NDEBUG to avoid warnings.
int n_dims = min.size();
assert(n_dims==max.size());
assert(n_dims==n_samples_per_dim.size());
#endif
MatrixXd inputs;
FunctionApproximator::generateInputsGrid(min, max, n_samples_per_dim, inputs);
MatrixXd lines;
getLines(inputs, lines);
MatrixXd activations;
if (cosine_basis_functions_)
{
BasisFunction::Cosine::activations(covars_,centers_,inputs,activations);
}
else
{
BasisFunction::Gaussian::activations(centers_,covars_,priors_,inputs,activations,normalized_basis_functions_);
if (normalized_basis_functions_)
{
MatrixXd unnormalized_activations;
BasisFunction::Gaussian::activations(centers_,covars_,priors_,inputs,unnormalized_activations,false);
saveMatrix(save_directory,"activations_unnormalized_grid.txt",unnormalized_activations,overwrite);
}
}
MatrixXd predictions;
evaluate(inputs,predictions);
saveMatrix(save_directory,"n_samples_per_dim.txt",n_samples_per_dim,overwrite);
saveMatrix(save_directory,"inputs_grid.txt",inputs,overwrite);
saveMatrix(save_directory,"lines_grid.txt",lines,overwrite);
saveMatrix(save_directory,"activations_grid.txt",activations,overwrite);
saveMatrix(save_directory,"predictions_grid.txt",predictions,overwrite);
return true;
}
int main(int argc, char** argv)
{
if(argc != 7){
printf("Usage: matmul <heightA> <widthA> <widthB> <file_MA> <file_MB> <output_file>\n");
return -1;
}
unsigned int HA, WA, WB;
HA = atoi(argv[1]);
WA = atoi(argv[2]);
WB = atoi(argv[3]);
float* h_A = loadMatrix(argv[4], HA, WA);
float* h_B = loadMatrix(argv[5], WA, WB);
float* h_C = (float*) malloc(sizeof(float)*HA*WB);
computeGold(h_C, h_A, h_B, HA, WA, WB);
saveMatrix(argv[6], h_C, HA, WB);
free(h_A);
free(h_B);
free(h_C);
systamp();
return 0;
}
int main (int argc, char* argv[])
{
double conv = 0.001;
int n, k = 0, save = 0;
struct timeval t0, tf;
double ep;
double *A = NULL, *b = NULL, *x0 = NULL;
if (argc < 2)
{
printf("Usage: jacobi [matrix_size] [--save]\n");
exit(0);
}
else if (argc == 3)
{
if (strcmp("--save", argv[2]) == 0)
{
save = 1;
}
else
{
printf("Unrecognized option \"%s\".\n", argv[2]);
printf("Usage: jacobi [matrix_size] [--save]\n");
exit(0);
}
}
n = atoi(argv[1]);
A = (double*) malloc(sizeof(double)*n*n);
b = (double*) malloc(sizeof(double)*n);
x0 = (double*) malloc(sizeof(double)*n);
// Creamos las matrices del problema
k = generateMatrices(A, b, x0, n);
if (k < 0)
{
fprintf(stderr, "Error generating input data: %s\n", strerror(k));
}
// Ejecutamos el problema
gettimeofday(&t0, NULL);
k = jacobi(A, b, x0, conv, n);
gettimeofday(&tf, NULL);
if (k < 0)
{
fprintf(stderr, "Error obtaining Jacobi solution: %s\n", strerror(k));
}
ep = (tf.tv_sec - t0.tv_sec) + (tf.tv_usec - t0.tv_usec) / 1000000.0;
// Borramos los datos inicializados al inicio del problema
// y mostramos las estadísticas (tamaño matriz, iteraciones y tiempo).
// Si se ha especificado, guardamos el resultado como archivo DLM.
setlocale(LC_NUMERIC, "es_ES.UTF-8");
printf("%d;%d;%.6f\n", n, k, ep);
if (save)
{
saveMatrix("x", x0, n, 1);
saveMatrix("A", A, n, 2);
saveMatrix("b", b, n, 1);
}
free(A);
free(b);
free(x0);
return 0;
}
bool Trajectory::saveToFile(string directory, string filename, bool overwrite) const
{
MatrixXd traj_matrix(length(),1+3*dim()+dim_misc());
traj_matrix << ts_, ys_, yds_, ydds_, misc_;
return saveMatrix(directory, filename, traj_matrix, overwrite);
}
int main(void) {
std::string filePath = "CNN-DocTermCountMatrix.txt";
Matrix& X_Ori = loadMatrix(filePath);
int NSample = min(20, X_Ori.getRowDimension());
Matrix& X = X_Ori.getSubMatrix(0, NSample - 1, 0, X_Ori.getColumnDimension() - 1);
// disp(X.getSubMatrix(0, 10, 0, 100));
println(sprintf("%d samples loaded", X.getRowDimension()));
GraphOptions& options = *new GraphOptions();
options.graphType = "nn";
std::string type = options.graphType;
double NN = options.graphParam;
fprintf("Graph type: %s with NN: %d\n", type.c_str(), (int)NN);
// Parameter setting for text data
options.kernelType = "cosine";
options.graphDistanceFunction = "cosine";
// Parameter setting for image data
/*options.kernelType = "rbf";
options.graphDistanceFunction = "euclidean";*/
options.graphNormalize = true;
options.graphWeightType = "heat";
bool show = true && !false;
// Test adjacency function - pass
tic();
std::string DISTANCEFUNCTION = options.graphDistanceFunction;
Matrix& A = adjacency(X, type, NN, DISTANCEFUNCTION);
fprintf("Elapsed time: %.2f seconds.\n", toc());
std::string adjacencyFilePath = "adjacency.txt";
saveMatrix(adjacencyFilePath, A);
if (show)
disp(A.getSubMatrix(0, 4, 0, 4));
// Test laplacian function - pass
tic();
Matrix& L = laplacian(X, type, options);
fprintf("Elapsed time: %.2f seconds.\n", toc());
std::string LaplacianFilePath = "Laplacian.txt";
saveMatrix(LaplacianFilePath, L);
if (show)
disp(L.getSubMatrix(0, 4, 0, 4));
// Test local learning regularization - pass
NN = options.graphParam;
std::string DISTFUNC = options.graphDistanceFunction;
std::string KernelType = options.kernelType;
double KernelParam = options.kernelParam;
double lambda = 0.001;
tic();
Matrix& LLR_text = calcLLR(X, NN, DISTFUNC, KernelType, KernelParam, lambda);
fprintf("Elapsed time: %.2f seconds.\n", toc());
std::string LLRFilePath = "localLearningRegularization.txt";
saveMatrix(LLRFilePath, LLR_text);
if (show)
display(LLR_text.getSubMatrix(0, 4, 0, 4));
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
int i;
int status;
if(argc < 2)
{
printf("Please provide a number of processes\n");
exit(0);
}
p = atoi(argv[1]);
if(p <= 0)
{
printf("The number of processes must be an integer larger than 0\n");
exit(0);
}
status = init();
switch(status)
{
case MATRIX1_ERROR:
printf("Error reading in1.txt\n");
exit(0);
case MATRIX2_ERROR:
printf("Error reading in2.txt\n");
exit(0);
case INCOMPATIBLE_ERROR:
printf("Matrices are incompatible\n");
exit(0);
default: /* case SUCCESS: */
break;
}
resultMatrix = (int**) calloc(m, sizeof(int*));
pthread_t* pthreads = (pthread_t*) calloc(p, sizeof(pthread_t));
int* threadNumber = (int*) calloc(p, sizeof(int));
for(i = 0; i < p; i++)
{
threadNumber[i] = i;
pthread_create(pthreads + i, NULL, fillMatrix, threadNumber + i);
}
for(i = 0; i < p; i++)
{
pthread_join(pthreads[i], NULL);
}
int success = saveMatrix(m, n, resultMatrix);
if(!success)
{
printf("Couldn't write to file out.txt");
}
for(i = 0; i < m; i++)
{
free(matrix1[i]);
}
free(matrix1);
for(i = 0; i < x; i++)
{
free(matrix2[i]);
}
free(matrix2);
for(i = 0; i < m; i++)
{
free(resultMatrix[i]);
}
free(resultMatrix);
return 0;
}
bool saveToDirectory(const UpdateSummaryParallel& summary, string directory, bool overwrite)
{
// Make directory if it doesn't already exist
if (!boost::filesystem::exists(directory))
{
if (!boost::filesystem::create_directories(directory))
{
cerr << __FILE__ << ":" << __LINE__ << ":";
cerr << "Couldn't make directory file '" << directory << "'." << endl;
return false;
}
}
// Abbreviations to make it fit on one line
bool ow = overwrite;
string dir = directory;
VectorXd cost_eval_vec = VectorXd::Constant(1,summary.cost_eval);
if (!saveMatrix(dir, "cost_eval.txt", cost_eval_vec, ow)) return false;
if (!saveMatrix(dir, "costs.txt", summary.costs, ow)) return false;
if (!saveMatrix(dir, "weights.txt", summary.weights, ow)) return false;
if (summary.cost_vars_eval.size()>0)
if (!saveMatrix(dir, "cost_vars_eval.txt",summary.cost_vars_eval, ow)) return false;
if (summary.cost_vars.size()>0)
if (!saveMatrix(dir, "cost_vars.txt",summary.cost_vars, ow)) return false;
int n_parallel = summary.distributions.size();
VectorXi n_parallel_vec = VectorXi::Constant(1,n_parallel);
saveMatrix(directory,"n_parallel.txt",n_parallel_vec,overwrite);
for (int ii=0; ii<n_parallel; ii++)
{
stringstream stream;
stream << "_" << setw(2) << setfill('0') << ii << ".txt";
string suf = stream.str();
if (!saveMatrix(dir, "distribution_mean"+suf, summary.distributions[ii]->mean(), ow))
return false;
if (!saveMatrix(dir, "distribution_covar"+suf, summary.distributions[ii]->covar(), ow))
return false;
if (!saveMatrix(dir, "samples"+suf, summary.samples[ii], ow))
return false;
if (!saveMatrix(dir, "distribution_new_mean"+suf, summary.distributions_new[ii]->mean(), ow))
return false;
if (!saveMatrix(dir, "distribution_new_covar"+suf, summary.distributions_new[ii]->covar(), ow))
return false;
}
return true;
}
int main(int argc, char** argv)
{
int n=0, j, k, i;
Matrix* matrix;
printf("Input the number of rows and columns of the matrix: ");
scanf("%d", &n);
if(n<0) n=0;
/*
* Test 1
*/
matrix = newMatrix(n, F);
i=1;
for(j=0; j<n; j++) {
for(k=0; k<n; k++) {
setMatrixEntry(matrix, i, j, k);
i++;
}
}
printf("F-Matrix before save:\n");
printMatrix(matrix);
saveMatrix(FILENAME, matrix);
matrix = delMatrix(matrix);
matrix = loadMatrix(FILENAME, n);
printf("F-Matrix after load:\n");
printMatrix(matrix);
matrix = delMatrix(matrix);
/*
* Test 2
*/
matrix = newMatrix(n, L);
i=1;
for(j=0; j<n; j++) {
for(k=0; k<=j; k++) {
setMatrixEntry(matrix, i, j, k);
i++;
}
}
printf("L-Matrix before save:\n");
printMatrix(matrix);
saveMatrix(FILENAME, matrix);
matrix = delMatrix(matrix);
matrix = loadMatrix(FILENAME, n);
printf("L-Matrix after load:\n");
printMatrix(matrix);
matrix = isLmatrix(matrix);
if(matrix == NULL)
return EXIT_FAILURE;
printf("L-Matrix conversion:\n");
printMatrix(matrix);
matrix = delMatrix(matrix);
/*
* Test 3
*/
matrix = newMatrix(n, U);
i=1;
for(j=0; j<n; j++) {
for(k=j; k<n; k++) {
setMatrixEntry(matrix, i, j, k);
i++;
}
}
printf("U-Matrix before save:\n");
printMatrix(matrix);
saveMatrix(FILENAME, matrix);
matrix = delMatrix(matrix);
matrix = loadMatrix(FILENAME, n);
printf("U-Matrix after load:\n");
printMatrix(matrix);
matrix = isUmatrix(matrix);
if(matrix == NULL)
return EXIT_FAILURE;
printf("U-Matrix conversion:\n");
printMatrix(matrix);
matrix = delMatrix(matrix);
return EXIT_SUCCESS;
}
DrawResult
ClippedImage::DrawSingleTile(gfxContext* aContext,
const nsIntSize& aSize,
const ImageRegion& aRegion,
uint32_t aWhichFrame,
SamplingFilter aSamplingFilter,
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aFlags)
{
MOZ_ASSERT(!MustCreateSurface(aContext, aSize, aRegion, aFlags),
"Shouldn't need to create a surface");
gfxRect clip(mClip.x, mClip.y, mClip.width, mClip.height);
nsIntSize size(aSize), innerSize(aSize);
bool needScale = false;
if (mSVGViewportSize && !mSVGViewportSize->IsEmpty()) {
innerSize = *mSVGViewportSize;
needScale = true;
} else if (NS_SUCCEEDED(InnerImage()->GetWidth(&innerSize.width)) &&
NS_SUCCEEDED(InnerImage()->GetHeight(&innerSize.height))) {
needScale = true;
} else {
MOZ_ASSERT_UNREACHABLE(
"If ShouldClip() led us to draw then we should never get here");
}
if (needScale) {
double scaleX = aSize.width / clip.width;
double scaleY = aSize.height / clip.height;
// Map the clip and size to the scale requested by the caller.
clip.Scale(scaleX, scaleY);
size = innerSize;
size.Scale(scaleX, scaleY);
}
// We restrict our drawing to only the clipping region, and translate so that
// the clipping region is placed at the position the caller expects.
ImageRegion region(aRegion);
region.MoveBy(clip.x, clip.y);
region = region.Intersect(clip);
gfxContextMatrixAutoSaveRestore saveMatrix(aContext);
aContext->Multiply(gfxMatrix::Translation(-clip.x, -clip.y));
auto unclipViewport = [&](const SVGImageContext& aOldContext) {
// Map the viewport to the inner image. Note that we don't take the aSize
// parameter of imgIContainer::Draw into account, just the clipping region.
// The size in pixels at which the output will ultimately be drawn is
// irrelevant here since the purpose of the SVG viewport size is to
// determine what *region* of the SVG document will be drawn.
CSSIntSize vSize(aOldContext.GetViewportSize());
vSize.width = ceil(vSize.width * double(innerSize.width) / mClip.width);
vSize.height =
ceil(vSize.height * double(innerSize.height) / mClip.height);
return SVGImageContext(vSize,
aOldContext.GetPreserveAspectRatio());
};
return InnerImage()->Draw(aContext, size, region,
aWhichFrame, aSamplingFilter,
aSVGContext.map(unclipViewport),
aFlags);
}
int main(void) {
std::string filePath = "CNN-DocTermCountMatrix.txt";
tic();
Matrix* X = null;
X = &loadMatrix(filePath);
/*Matrix& Y = X->getSubMatrix(0, 29, 0, 999);
saveMatrix(Y, "CNN-SubDocTermCountMatrix.txt");*/
/*double data[3][4] = {
{3.5, 5.3, 0.2, -1.2},
{4.4, 2.2, 0.3, 0.4},
{1.3, 0.5, 4.1, 3.2}
};
X = &DenseMatrix::createDenseMatrix<4>(data, 3, 4);*/
X = &X->transpose();
X = &getTFIDF(*X);
X = &normalizeByColumns(*X);
X = &X->transpose();
KMeansOptions& kMeansOptions = *new KMeansOptions();
kMeansOptions.nClus = 10;
kMeansOptions.maxIter = 50;
kMeansOptions.verbose = true;
Clustering& kmeans = *new KMeans(kMeansOptions);
kmeans.feedData(*X);
// KMeans.initialize(null);
kmeans.clustering();
Matrix* G0 = kmeans.getIndicatorMatrix();
/*disp("G0:");
printMatrix(*G0);*/
// Matrix X = Data.loadSparseMatrix("X.txt");
// G0 = loadDenseMatrix("G0.txt");
NMFOptions& nmfOptions = *new NMFOptions();
nmfOptions.nClus = 10;
nmfOptions.maxIter = 300;
nmfOptions.verbose = true;
nmfOptions.calc_OV = !true;
nmfOptions.epsilon = 1e-5;
Clustering& nmf = *new NMF(nmfOptions);
nmf.feedData(*X);
// L1NMF.initialize(G0);
// Matlab takes 12.5413 seconds
// jblas takes 29.368 seconds
// Commons-math takes 129 seconds (Using Array2DRowRealMatrix)
// Commons-math takes 115 seconds (Using DenseMatrix)
// start = System.currentTimeMillis();
nmf.clustering(G0); // Use null for random initialization
fprintf("Elapsed time: %.3f seconds\n", toc());
/*disp(*nmf.getCenters());
disp(*nmf.getIndicatorMatrix());*/
saveMatrix("F.txt", *nmf.getCenters());
saveMatrix("G.txt", *nmf.getIndicatorMatrix());
return EXIT_SUCCESS;
}
void runOptimizationTask(
const Task* const task,
const TaskSolver* const task_solver,
const DistributionGaussian* const initial_distribution,
const Updater* const updater,
int n_updates,
int n_samples_per_update,
std::string save_directory,
bool overwrite,
bool only_learning_curve)
{
int n_cost_components = task->getNumberOfCostComponents();
// Some variables
VectorXd sample_eval;
MatrixXd cost_vars_eval;
VectorXd cost_eval(1+n_cost_components);
MatrixXd samples;
MatrixXd cost_vars;
VectorXd weights;
MatrixXd costs(n_samples_per_update,1+n_cost_components);
// tmp variables
VectorXd total_costs(n_samples_per_update);
VectorXd cur_cost(1+n_cost_components);
// Bookkeeping
MatrixXd learning_curve(n_updates,2+n_cost_components);
MatrixXd exploration_curve(n_updates,2);
if (save_directory.empty())
cout << "init = " << " distribution=" << *initial_distribution;
DistributionGaussian distribution = *(initial_distribution->clone());
DistributionGaussian distribution_new = *(initial_distribution->clone());
// Optimization loop
for (int i_update=0; i_update<n_updates; i_update++)
{
// 0. Get cost of current distribution mean
sample_eval = distribution.mean().transpose();
task_solver->performRollout(sample_eval,cost_vars_eval);
task->evaluateRollout(cost_vars_eval,sample_eval,cost_eval);
Rollout* rollout_eval = new Rollout(sample_eval,cost_vars_eval,cost_eval);
// 1. Sample from distribution
distribution.generateSamples(n_samples_per_update, samples);
vector<Rollout*> rollouts(n_samples_per_update);
for (int i_sample=0; i_sample<n_samples_per_update; i_sample++)
{
// 2A. Perform the rollout
task_solver->performRollout(samples.row(i_sample),cost_vars);
// 2B. Evaluate the rollout
task->evaluateRollout(cost_vars,samples.row(i_sample),cur_cost);
costs.row(i_sample) = cur_cost;
rollouts[i_sample] = new Rollout(samples.row(i_sample),cost_vars,cur_cost);
}
// 3. Update parameters (first column of costs contains sum of cost components)
total_costs = costs.col(0);
updater->updateDistribution(distribution, samples, total_costs, weights, distribution_new);
// Bookkeeping
// Some output and/or saving to file (if "directory" is set)
if (save_directory.empty())
{
cout << "\t cost_eval=" << cost_eval << endl << i_update+1 << " " << distribution;
}
else
{
// Update learning curve
// How many samples?
int i_samples = i_update*n_samples_per_update;
learning_curve(i_update,0) = i_samples;
// Cost of evaluation
learning_curve.block(i_update,1,1,1+n_cost_components) = cost_eval.transpose();
// Exploration magnitude
exploration_curve(i_update,0) = i_samples;
exploration_curve(i_update,1) = sqrt(distribution.maxEigenValue());
// Save more than just learning curve.
if (!only_learning_curve)
{
saveToDirectory(save_directory,i_update,distribution,rollout_eval,rollouts,weights,distribution_new);
if (i_update==0)
task->savePlotRolloutScript(save_directory);
}
}
// Distribution is new distribution
distribution = distribution_new;
}
// Save learning curve to file, if necessary
if (!save_directory.empty())
{
// Todo: save cost labels also
saveMatrix(save_directory, "exploration_curve.txt",exploration_curve,overwrite);
saveMatrix(save_directory, "learning_curve.txt",learning_curve,overwrite);
}
}
int main(int argc, char **argv) {
///******************************************************
///********************** INPUT *************************
///******************************************************
if (argc != 4) {
std::cout << "Invalid number of arguments!" << std::endl;
std::cout << "./compare A.out B.out" << std::endl;
exit(EXIT_FAILURE);
}
//matrix dimensions
int dimM = 0;
int dimN = 0;
int dimO = 0;
//get dimensions
std::ifstream fIn(argv[1]);
if (!fIn) {
std::cout << "Error opening file: " << argv[1] << std::endl;
exit(EXIT_FAILURE);
}
if(!(fIn >> dimM >> dimN))
{
std::cout << "Error in reading matrix entries!" << std::endl;
exit(EXIT_FAILURE);
}
fIn.close();
fIn.open(argv[2]);
if (!fIn) {
std::cout << "Error opening file: " << argv[2] << std::endl;
exit(EXIT_FAILURE);
}
if(!(fIn >> dimN >> dimO))
{
std::cout << "Error in reading matrix entries!" << std::endl;
exit(EXIT_FAILURE);
}
fIn.close();
//calculate minimal matrix size
//all matrices are padded with 0s to this size
//should be power of 2 for efficient block division
//dirty hack...
LD = 64;
if (LD<dimM) LD = dimM;
if (LD<dimN) LD = dimN;
if (LD<dimO) LD = dimO;
LD--;
LD |= LD >> 1;
LD |= LD >> 2;
LD |= LD >> 4;
LD |= LD >> 8;
LD |= LD >> 16;
LD++;
//add useless padding
LD += PADDING;
double* a = (double*) aligned_alloc(ALIGNMENT, sizeof(double) * LD * LD);
double* b = (double*) aligned_alloc(ALIGNMENT, sizeof(double) * LD * LD);
double* c = (double*) aligned_alloc(ALIGNMENT, sizeof(double) * LD * LD);
Matrix A = loadMatrix(argv[1], &a[0]);
Matrix B = loadMatrix(argv[2], &b[0]);
Matrix C(&c[0], nullptr, A.getDimM(), B.getDimN(), 0, 0);
///******************************************************
///********************** CALCULATION *******************
///******************************************************
double time = 0;
#ifdef USE_LIKWID
likwid_markerInit();
likwid_markerStartRegion("dummy");
#endif
siwir::Timer timer;
MMM(A, B, C);
time = timer.elapsed();
std::cout << dimM << "\t" << dimN << "\t" << dimO << "\t" << time << std::endl;
#ifdef USE_LIKWID
likwid_markerStopRegion("dummy");
likwid_markerClose();
#endif
///******************************************************
///********************** OUTPUT ************************
///******************************************************
saveMatrix(argv[3], C);
free(a);
free(b);
free(c);
};
void BundlerMatcher::open(const std::string& inputPath, const std::string& inputFilename, const std::string& outMatchFilename)
{
mInputPath = inputPath;
if (!mIsInitialized)
{
std::cout << "Error : can not initialize opengl context for SiftGPU" <<std::endl;
return;
}
if (!parseListFile(inputFilename))
{
std::cout << "Error : can not open file : " <<inputFilename.c_str() <<std::endl;
return;
}
//Sift Feature Extraction
for (unsigned int i=0; i<mFilenames.size(); ++i)
{
int percent = (int)(((i+1)*100.0f) / (1.0f*mFilenames.size()));
int nbFeature = extractSiftFeature(i);
clearScreen();
std::cout << "[Extracting Sift Feature : " << percent << "%] - ("<<i+1<<"/"<<mFilenames.size()<<", #"<< nbFeature <<" features)";
}
clearScreen();
std::cout << "[Sift Feature extracted]"<<std::endl;
for (unsigned int i=0; i<mFilenames.size(); ++i)
{
int percent = (int)(((i+1)*100.0f) / (1.0f*mFilenames.size()));
saveAsciiKeyFile(i);
if (mBinaryKeyFileWritingEnabled)
saveBinaryKeyFile(i);
clearScreen();
std::cout << "[Saving Sift Key files: " << percent << "%] - ("<<i+1<<"/"<<mFilenames.size()<<")";
}
saveVector();
clearScreen();
std::cout << "[Sift Key files saved]"<<std::endl;
delete mSift;
mSift = NULL;
mMatcher->VerifyContextGL();
//Sift Matching
int currentIteration = 0;
if (mSequenceMatchingEnabled) //sequence matching (video input)
{
std::cout << "[Sequence matching enabled: length " << mSequenceMatchingLength << "]" << std::endl;
int maxIterations = (int) (mFilenames.size()-mSequenceMatchingLength)*mSequenceMatchingLength + mSequenceMatchingLength*(mSequenceMatchingLength-1)/2; // (N-m).m + m(m-1)/2
for (unsigned int i=0; i<mFilenames.size()-1; ++i)
{
for (int j=1; j<=mSequenceMatchingLength; ++j)
{
int indexA = i;
int indexB = i+j;
if (indexB >= mFilenames.size())
continue;
else
{
clearScreen();
int percent = (int) (currentIteration*100.0f / maxIterations*1.0f);
std::cout << "[Matching Sift Feature : " << percent << "%] - (" << indexA << "/" << indexB << ")";
matchSiftFeature(indexA, indexB);
currentIteration++;
}
}
}
}
else //classic quadratic matching
{
int maxIterations = (int) mFilenames.size()*((int) mFilenames.size()-1)/2; // Sum(1 -> n) = n(n-1)/2
for (unsigned int i=0; i<mFilenames.size(); ++i)
{
for (unsigned int j=i+1; j<mFilenames.size(); ++j)
{
clearScreen();
int percent = (int) (currentIteration*100.0f / maxIterations*1.0f);
std::cout << "[Matching Sift Feature : " << percent << "%] - (" << i << "/" << j << ")";
matchSiftFeature(i, j);
currentIteration++;
}
}
}
clearScreen();
std::cout << "[Sift Feature matched]"<<std::endl;
delete mMatcher;
mMatcher = NULL;
saveMatches(outMatchFilename);
saveMatrix();
}
void FunctionApproximator::train(const MatrixXd& inputs, const MatrixXd& targets, string save_directory, bool overwrite)
{
train(inputs,targets);
if (save_directory.empty())
return;
if (!isTrained())
return;
if (getExpectedInputDim()<3)
{
VectorXd min = inputs.colwise().minCoeff();
VectorXd max = inputs.colwise().maxCoeff();
int n_samples_per_dim = 100;
if (getExpectedInputDim()==2) n_samples_per_dim = 40;
VectorXi n_samples_per_dim_vec = VectorXi::Constant(getExpectedInputDim(),n_samples_per_dim);
model_parameters_->saveGridData(min, max, n_samples_per_dim_vec, save_directory, overwrite);
}
MatrixXd outputs;
predict(inputs,outputs);
saveMatrix(save_directory,"inputs.txt",inputs,overwrite);
saveMatrix(save_directory,"targets.txt",targets,overwrite);
saveMatrix(save_directory,"outputs.txt",outputs,overwrite);
string filename = save_directory+"/plotdata.py";
ofstream outfile;
outfile.open(filename.c_str());
if (!outfile.is_open())
{
cerr << __FILE__ << ":" << __LINE__ << ":";
cerr << "Could not open file " << filename << " for writing." << endl;
}
else
{
// Python code generation in C++. Rock 'n' roll! ;-)
if (inputs.cols()==2) {
outfile << "from mpl_toolkits.mplot3d import Axes3D \n";
}
outfile << "import numpy \n";
outfile << "import matplotlib.pyplot as plt \n";
outfile << "directory = '" << save_directory << "' \n";
outfile << "inputs = numpy.loadtxt(directory+'/inputs.txt') \n";
outfile << "targets = numpy.loadtxt(directory+'/targets.txt') \n";
outfile << "outputs = numpy.loadtxt(directory+'/outputs.txt') \n";
outfile << "fig = plt.figure() \n";
if (inputs.cols()==2) {
outfile << "ax = Axes3D(fig) \n";
outfile << "ax.plot(inputs[:,0],inputs[:,1],targets, '.', label='targets',color='black') \n";
outfile << "ax.plot(inputs[:,0],inputs[:,1],outputs, '.', label='predictions',color='red')\n";
outfile << "ax.set_xlabel('input_1'); ax.set_ylabel('input_2'); ax.set_zlabel('output') \n";
outfile << "ax.legend(loc='lower right') \n";
} else {
outfile << "plt.plot(inputs,targets, '.', label='targets',color='black') \n";
outfile << "plt.plot(inputs,outputs, '.', label='predictions',color='red') \n";
outfile << "plt.xlabel('input'); plt.ylabel('output'); \n";
outfile << "plt.legend(loc='lower right') \n";
}
outfile << "plt.show() \n";
outfile << endl;
outfile.close();
//cout << " ______________________________________________________________" << endl;
//cout << " | Plot saved data with:" << " 'python " << filename << "'." << endl;
//cout << " |______________________________________________________________" << endl;
}
}
void CTCDecoderLayer::runForwardImplementation(Bundle& bundle)
{
auto& inputActivationsVector = bundle[ "inputActivations"].get<MatrixVector>();
auto& outputActivationsVector = bundle["outputActivations"].get<MatrixVector>();
assert(inputActivationsVector.size() == 1);
auto inputActivations = inputActivationsVector.back();
saveMatrix("inputActivations", inputActivations);
auto beamSearchOutputSize = matrix::getBeamSearchOutputSize(
inputActivations.size(), _implementation->getBeamSize());
size_t miniBatchSize = inputActivations.size()[inputActivations.size().size() - 2];
size_t timesteps = inputActivations.size()[inputActivations.size().size() - 1];
Matrix inputPaths({_implementation->getBeamSize(), miniBatchSize, timesteps},
inputActivations.precision());
Matrix outputActivations(beamSearchOutputSize, inputActivations.precision());
Matrix outputActivationWeights({_implementation->getBeamSize(), miniBatchSize},
inputActivations.precision());
matrix::ctcBeamSearch(outputActivationWeights, inputPaths, outputActivations,
inputActivations, _implementation->getBeamSize());
reshapeOutputActivations(outputActivations, inputActivations.size(),
_implementation->getBeamSize());
bundle["outputActivationWeights"] = outputActivationWeights;
saveMatrix("outputActivationWeights", outputActivationWeights);
saveMatrix("inputPaths", inputPaths);
if(util::isLogEnabled("CTCDecoderLayer::Detail"))
{
util::log("CTCDecoderLayer::Detail") << " output activation: "
<< outputActivations.debugString();
util::log("CTCDecoderLayer::Detail") << " input paths: "
<< inputPaths.debugString();
util::log("CTCDecoderLayer::Detail") << " output activation weights: "
<< outputActivationWeights.debugString();
}
else
{
util::log("CTCDecoderLayer") << " output activation size: "
<< outputActivations.shapeString() << "\n";
util::log("CTCDecoderLayer") << " input paths: "
<< inputPaths.shapeString() << "\n";
util::log("CTCDecoderLayer") << " output activation weights: "
<< outputActivationWeights.shapeString() << "\n";
}
_implementation->saveInputLabels( bundle["referenceLabels"].get<LabelVector>());
_implementation->saveInputTimesteps(bundle["inputTimesteps" ].get<IndexVector>());
outputActivationsVector.push_back(outputActivations);
expandLabels(bundle, _implementation->getBeamSize());
if(_implementation->hasCostFunction())
{
auto inputTimesteps = _implementation->getInputTimesteps();
auto inputLabels = _implementation->getInputLabels();
computeCtcCosts(bundle, _implementation->getCostFunctionName(),
_implementation->getCostFunctionWeight(),
inputActivations, inputLabels, inputTimesteps);
}
}
