├── .gitignore
├── distnmf
    ├── .gitignore
    ├── eos.sh
    ├── distr2.hpp
    ├── distals.hpp
    ├── CMakeLists.txt
    ├── README.md
    ├── disthals.hpp
    ├── distanlsbpp.hpp
    ├── distmu.hpp
    ├── mpicomm.hpp
    ├── distnmf.hpp
    └── distnmftime.hpp
├── utilities
    ├── buildsplitfiles.sh
    ├── py2mpiio.cpp
    ├── partitioner
    │   ├── planc_benchmark.py
    │   ├── run_partitioner.py
    │   ├── planc_output_convert.py
    │   ├── configs
    │   │   └── bench_configs.json
    │   ├── planc_partitioner.py
    │   └── check_symm.py
    ├── splitfiles2d.sh
    ├── splitfiles.sh
    ├── processstackexchange.txt
    ├── permute-sparse-struct.cpp
    ├── README.md
    ├── shufflesparsemm.py
    └── partition-uniform.cpp
├── datasets.md
├── ntf
    ├── ntfmu.hpp
    ├── ntfhals.hpp
    ├── mttkrp_test.cpp
    ├── CMakeLists.txt
    ├── ntf.cpp
    ├── ntfanlsbpp.hpp
    ├── README.md
    ├── ntfaoadmm.hpp
    └── ntfnes.hpp
├── jointnmf
    ├── jointnmf_driver.hpp
    ├── CMakeLists.txt
    └── README.md
├── distjointnmf
    ├── distjointnmf_driver.hpp
    ├── CMakeLists.txt
    ├── README.md
    └── distjnmftime.hpp
├── nnls
    └── SortBooleanMatrix.hpp
├── distntf
    ├── distntfcpals.hpp
    ├── distntfmu.hpp
    ├── CMakeLists.txt
    ├── distntfhals.hpp
    ├── testcases.md
    ├── distntfanlsbpp.hpp
    ├── README.md
    ├── distntftime.hpp
    ├── distntfaoadmm.hpp
    └── distntf.cpp
├── nmf
    ├── CMakeLists.txt
    ├── sampletest.cpp
    ├── mu.hpp
    ├── README.md
    ├── hals.hpp
    └── aoadmm.hpp
├── common
    ├── ntf_utils.hpp
    ├── utils.h
    ├── distutils.h
    ├── cmake_aux
    │   └── NMFLIB_FindARMA.cmake
    ├── npyio.hpp
    └── parsecommandline.h
├── CMakeLists.txt
├── dimtree
    └── dimtrees.h
├── license.dat
├── conf
    ├── nvblas_cuda91.conf
    └── nvblas_cuda75.conf
├── papers.md
├── formatter
    └── google_clang_format
├── hiernmf
    ├── CMakeLists.txt
    ├── README.md
    ├── matutils.hpp
    └── hiernmf.cpp
└── testcases.md


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | *.pdf
3 | *.md5
4 | *.dpth
5 | *.dep
6 | 


--------------------------------------------------------------------------------
/distnmf/.gitignore:
--------------------------------------------------------------------------------
1 | CMake*
2 | cmake*
3 | Makefile
4 | distnmf
5 | spmat*
6 | .*.swp
7 | mpiout*
8 | pacoss
9 | 


--------------------------------------------------------------------------------
/utilities/buildsplitfiles.sh:
--------------------------------------------------------------------------------
1 | g++ -fopenmp -c -O3 -I /home/rkannan3/libraries/armadillo-4.450.3/include/ SplitFiles.cpp
2 | 


--------------------------------------------------------------------------------
/datasets.md:
--------------------------------------------------------------------------------
1 | # Datasets
2 | Links to some datasets generated as part of the PLANC project.
3 | * Pixel similarity matrices used in SymNMF experiments. [[doi]](https://doi.org/10.5281/zenodo.3877635)
4 | * Aminer-MAG dataset used in JointNMF experiments. [[doi]](https://doi.org/10.5281/zenodo.7893403), [[doi]](https://doi.org/10.5281/zenodo.7938102)


--------------------------------------------------------------------------------
/utilities/py2mpiio.cpp:
--------------------------------------------------------------------------------
 1 | /* Copyright Ramakrishnan Kannan 2018 */
 2 | 
 3 | #include "common/npyio.hpp"
 4 | 
 5 | /*
 6 | * For converting numpy array to distributed io
 7 | * Compile as g++ -D_FILE_OFFSET_BITS=64 py2mpiio.cpp 
 8 | * -I/ccs/home/ramki/nmflibrary/  -I$ARMADILLO_INCLUDE_DIR  
 9 | * -I/ccs/home/ramki/rhea/libraries/openblas/include/
10 | */
11 | 
12 | int main(int argc, char *argv[]) {
13 |   if (argc < 3) {
14 |     std::cout << "Usage : py2mpiio inputfile.npy outputfilename" << std::endl;
15 |     return -1;
16 |   }
17 |   planc::NumPyArray npa;
18 |   npa.load(argv[1]);
19 |   npa.m_input_tensor->write(argv[2]);
20 |   return 0;
21 | }


--------------------------------------------------------------------------------
/ntf/ntfmu.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright Ramakrishnan Kannan 2018 */
 2 | 
 3 | #ifndef NTF_NTFMU_HPP_
 4 | #define NTF_NTFMU_HPP_
 5 | 
 6 | #include "ntf/auntf.hpp"
 7 | 
 8 | namespace planc {
 9 | class NTFMU : public AUNTF {
10 |  protected:
11 |   MAT update(const int mode) {
12 |     MAT H(this->m_ncp_factors.factor(mode));
13 |     MAT temp = H * this->gram_without_one + EPSILON;
14 |     H = (H % this->ncp_mttkrp_t[mode].t()) / temp;
15 |     return H.t();
16 |   }
17 | 
18 |  public:
19 |   NTFMU(const Tensor &i_tensor, const int i_k, algotype i_algo)
20 |       : AUNTF(i_tensor, i_k, i_algo) {}
21 | };  // class NTFMU
22 | }  // namespace planc
23 | 
24 | #endif  // NTF_NTFMU_HPP_
25 | 


--------------------------------------------------------------------------------
/jointnmf/jointnmf_driver.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright 2022 Ramakrishnan Kannan */
 2 | #ifndef JOINTNMFDRIVER_HPP_
 3 | #define JOINTNMFDRIVER_HPP_
 4 | 
 5 | #include "common/nmf.hpp"
 6 | #include <stdio.h>
 7 | #include <string>
 8 | #include "common/parsecommandline.hpp"
 9 | #include "common/utils.hpp"
10 | #include "jointnmf/anlsbppjnmf.hpp"
11 | #include "jointnmf/pgdjnmf.hpp"
12 | #include "jointnmf/pgncgjnmf.hpp"
13 | 
14 | // TODO: move class defintion into here
15 | 
16 |     template <class NMFTYPE, class T1, class T2>
17 |     void callJointNMF();
18 | 
19 |     // template parameters with template paramters
20 |     template <template <class, class> class NMFTYPE>
21 |     void build_opts();
22 | 
23 | #endif  // JOINTNMFDRIVER_HPP_


--------------------------------------------------------------------------------
/distnmf/eos.sh:
--------------------------------------------------------------------------------
1 | export MKL_ROOT=/opt/intel/composer_xe_2015.2.164/mkl/
2 | source /opt/intel/composer_xe_2015.2.164/mkl/bin/mklvars.sh intel64
3 | export MPI_C_LIBRARIES="-Wl,--start-group /opt/cray/mpt/default/gni/mpich2-gnu/5.1/lib/libmpich_gnu_51.a /opt/cray/pmi/default/lib64/libpmi.a /opt/cray/alps/default/lib64/libalpsutil.a /opt/cray/alps/default/lib64/libalpslli.a /opt/cray/alps/default/lib64/libalps.a /opt/cray/wlm_detect/default/lib64/libwlm_detect.a /opt/cray/ugni/default/lib64/libugni.a /opt/cray/udreg/default/lib64/libudreg.a /opt/cray/xpmem/default/lib64/libxpmem.a -lpthread /usr/lib64/librt.a -Wl,--end-group"
4 | cmake $1 -DCMAKE_BUILD_SPARSE=1 -DMPI_CXX_INCLUDE_PATH=/opt/cray/mpt/default/gni/mpich2-gnu/5.1/include -DMPI_CXX_LIBRARIES="$MPI_C_LIBRARIES"
5 | 
6 | 


--------------------------------------------------------------------------------
/distjointnmf/distjointnmf_driver.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright 2022 Ramakrishnan Kannan */
 2 | #ifndef DISTJNMFDRIVER_HPP_
 3 | #define DISTJNMFDRIVER_HPP_
 4 | 
 5 | #include <string>
 6 | #include "common/distutils.hpp"
 7 | #include "common/parsecommandline.hpp"
 8 | #include "common/utils.hpp"
 9 | #include "distjointnmf/distjointnmfio.hpp"
10 | #include "distjointnmf/distanlsbppjnmf.hpp"
11 | #include "distjointnmf/jnmfmpicomm.hpp"
12 | #include "distjointnmf/distpgdjnmf.hpp"
13 | #include "distjointnmf/distpgncgjnmf.hpp"
14 | 
15 | // TODO: move classs defintion into here
16 | 
17 |     template <class NMFTYPE, class T1, class T2>
18 |     void callDistJointNMF();
19 | 
20 |     // template parameters with template paramters
21 |     template <template <class, class> class NMFTYPE>
22 |     void build_opts();
23 | 
24 | #endif  // DISTJNMFDRIVER_HPP_


--------------------------------------------------------------------------------
/utilities/partitioner/planc_benchmark.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | import sys
 3 | config_path = sys.argv[1]
 4 | f = open(config_path)
 5 | config = json.load(f)
 6 | f.close()
 7 | 
 8 | print(list(config.keys()))
 9 | 
10 | 
11 | for config_id in list(config.keys()):
12 |     print(config_id)
13 |     c = config[config_id][0]
14 |     print(c)
15 | 
16 | 
17 |     for procs in range(len(c['procs'])):
18 |         # do partitioning here, set partition to false in generated scripts ----> assume no
19 |         # overwrites ----> mkdirs to prevent this ----> beware of using lost of memory...
20 |         for algorithm in c['algorithm']:
21 |             for k in c['k']:
22 |                 for iterations in c['iterations']:
23 | 
24 |                     if algorithm == 9:
25 |                         for alpha in c['alpha']:
26 |                             for beta in c['beta']:
27 |                                 pass
28 |                                 
29 |                     else:
30 |                         pass
31 | 


--------------------------------------------------------------------------------
/ntf/ntfhals.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright Ramakrishnan Kannan 2018 */
 2 | 
 3 | #ifndef NTF_NTFHALS_HPP_
 4 | #define NTF_NTFHALS_HPP_
 5 | 
 6 | #include "ntf/auntf.hpp"
 7 | #include "common/utils.hpp"
 8 | 
 9 | namespace planc {
10 | 
11 | class NTFHALS : public AUNTF {
12 |  protected:
13 |   MAT update(const int mode) {
14 |     MAT H(this->m_ncp_factors.factor(mode));
15 |     // iterate over all columns of H
16 |     for (int i = 0; i < this->m_ncp_factors.rank(); i++) {
17 |       VEC updHi =
18 |           H.col(i) + ((this->ncp_mttkrp_t[mode].row(i)).t() -
19 |                       H * this->gram_without_one.col(i));
20 |       fixNumericalError<VEC>(&updHi, EPSILON_1EMINUS16, EPSILON_1EMINUS16);
21 |       double normHi = arma::norm(updHi, 2);
22 |       normHi *= normHi;
23 |       double globalnormHi = normHi;
24 |       if (globalnormHi > 0) {
25 |         H.col(i) = updHi;
26 |       }
27 |     }
28 |     return H.t();
29 |   }
30 | 
31 |  public:
32 |   NTFHALS(const Tensor &i_tensor, const int i_k, algotype i_algo)
33 |       : AUNTF(i_tensor, i_k, i_algo) {}
34 | };  // class NTFHALS
35 | 
36 | }  // namespace planc
37 | 
38 | #endif  // NTF_NTFHALS_HPP_
39 | 


--------------------------------------------------------------------------------
/ntf/mttkrp_test.cpp:
--------------------------------------------------------------------------------
 1 | /* Copyright 2017 Ramakrishnan Kannan */
 2 | 
 3 | #include <armadillo>
 4 | #include "ncpfactors.hpp"
 5 | #include "ntf_utils.hpp"
 6 | #include "tensor.hpp"
 7 | #include "utils.h"
 8 | 
 9 | int main(int argc, char* argv[]) {
10 |   int test_order = 5;
11 |   int low_rank = 2;
12 |   UVEC dimensions(test_order);
13 |   FMAT* mttkrps = new FMAT[test_order];
14 |   // UVEC dimensions(4);
15 |   for (int i = 0; i < test_order; i++) {
16 |     dimensions(i) = i + 2;
17 |   }
18 |   // dimensions(3) = 6;
19 |   PLANC::NCPFactors cpfactors(dimensions, low_rank);
20 |   cpfactors.print();
21 |   FMAT krp_2 = cpfactors.krp_leave_out_one(2);
22 |   cout << "krp" << endl << "------" << endl << krp_2;
23 |   PLANC::Tensor my_tensor = cpfactors.rankk_tensor();
24 |   // cout << "input tensor" << endl << "--------" << endl;
25 |   // my_tensor.print();
26 |   for (int i = 0; i < test_order; i++) {
27 |     mttkrps[i] = arma::zeros<FMAT>(dimensions(i), low_rank);
28 |   }
29 |   for (int i = 0; i < test_order; i++) {
30 |     mttkrp(i, my_tensor, cpfactors, &mttkrps[i]);
31 |     cout << "mttkrp " << i << endl << "---------" << endl << mttkrps[i];
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/utilities/splitfiles2d.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | #It splits the dense matrix into row splits and column splits
 3 | #Every file will have equal number of lines in Arows_#cores_idx
 4 | #and equal columsn in Acols_#cores_idx
 5 | #Run as : splitfiles.sh filename #pr #pc
 6 | pr=$2
 7 | pc=$3
 8 | totalLines=$(wc -l < $1)
 9 | numLines=$(( $totalLines / $pr ))
10 | outputdir=${pr}cores
11 | rm -rf $outputdir
12 | mkdir $outputdir
13 | #------------------------------
14 | #row split
15 | split -a 3 -l ${numLines} $1 $outputdir/Arows_${pr}_
16 | 
17 | #rename the file suffixes with numbers
18 | i=0
19 | for file in $outputdir/Arows_*
20 | do
21 |   mv $file $outputdir/Arows_${pr}_${i}
22 |   i=$(( i + 1 ))
23 | done
24 | i=0
25 | #-------------------------------
26 | #column split
27 | for file in $outputdir/Arows_*
28 | do  
29 |   numCols=$(gawk -F' ' '{print NF; exit}' $file)
30 |   perCol=$(( ${numCols} / ${pc} ))
31 |   num1=$(( ${i} * ${pc} ))
32 |   i=$(( i + 1 ))
33 |   for ((j=0;j<pc;j++ ))
34 |   do
35 |     #j=$((i+1))     
36 |     idx=$(( num1 + j ))
37 |     cut -f$((((${j}*${perCol})+1)))-$((((${j}+1)*${perCol}))) -d " " $file >> ${outputdir}/A_${idx} 2>&1
38 |   done  
39 | done
40 | 
41 | rm $outputdir/Arows_*
42 | #-------------------------------------
43 | 
44 | 


--------------------------------------------------------------------------------
/nnls/SortBooleanMatrix.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright 2016 Ramakrishnan Kannan */
 2 | 
 3 | #ifndef NNLS_SORTBOOLEANMATRIX_HPP_
 4 | #define NNLS_SORTBOOLEANMATRIX_HPP_
 5 | #include <armadillo>
 6 | #include <vector>
 7 | #include <algorithm>
 8 | 
 9 | template <class T>
10 | class BooleanArrayComparator {
11 |     const T &X;
12 |  public:
13 |     explicit BooleanArrayComparator(const T &input): X(input) {
14 |     }
15 |     /*
16 |     * if idxi < idxj return true;
17 |     * if idxi >= idxj return false;
18 |     */
19 |     bool operator() (UWORD idxi, UWORD idxj) {
20 |         for (uint i = 0; i < X.n_rows; i++) {
21 |             if (this->X(i, idxi) < this->X(i, idxj))
22 |                 return true;
23 |             else if (this->X(i, idxi) > this->X(i, idxj))
24 |                 return false;
25 |         }
26 |         return false;
27 |     }
28 | };
29 | 
30 | template <class T>
31 | class SortBooleanMatrix {
32 |     const T &X;
33 |     std::vector<UWORD> idxs;
34 |  public:
35 |     explicit SortBooleanMatrix(const T &input) : X(input), idxs(X.n_cols) {
36 |         for (uint i = 0; i < X.n_cols; i++) {
37 |             idxs[i] = i;
38 |         }
39 |     }
40 |     std::vector<UWORD> sortIndex() {
41 |         std::sort(this->idxs.begin(), this->idxs.end(),
42 |              BooleanArrayComparator<T>(this->X));
43 |         return this->idxs;
44 |     }
45 | };
46 | #endif  // NNLS_SORTBOOLEANMATRIX_HPP_
47 | 


--------------------------------------------------------------------------------
/distntf/distntfcpals.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright Ramakrishnan Kannan 2018 */
 2 | 
 3 | #ifndef DISTNTF_DISTNTFCPALS_HPP_
 4 | #define DISTNTF_DISTNTFCPALS_HPP_
 5 | 
 6 | #include "distntf/distauntf.hpp"
 7 | 
 8 | namespace planc {
 9 | 
10 | class DistNTFCPALS : public DistAUNTF {
11 |  protected:
12 |   /**
13 |    * This is unconstrained CP ALS update function.
14 |    * Given the MTTKRP and the hadamard of all the grams, we
15 |    * determine the factor matrix to be updated.
16 |    * @param[in] Mode of the factor to be updated
17 |    * @returns The new updated factor
18 |    */
19 |   MAT update(const int mode) {
20 |     MAT Ht = this->m_local_ncp_factors.factor(mode).t();
21 |     if (m_nls_sizes[mode] > 0) {
22 |       Ht = arma::solve(this->global_gram, this->ncp_local_mttkrp_t[mode]);
23 |     } else {  // Return unmodified factor
24 |       Ht.zeros();
25 |     }
26 |     return Ht;
27 |   }
28 | 
29 |  public:
30 |   DistNTFCPALS(const Tensor &i_tensor, const int i_k, algotype i_algo,
31 |                const UVEC &i_global_dims, const UVEC &i_local_dims,
32 |                const UVEC &i_nls_sizes, const UVEC &i_nls_idxs,
33 |                const NTFMPICommunicator &i_mpicomm)
34 |       : DistAUNTF(i_tensor, i_k, i_algo, i_global_dims, i_local_dims,
35 |                   i_nls_sizes, i_nls_idxs, i_mpicomm) {}
36 | };  // class DistNTFMU
37 | 
38 | }  // namespace planc
39 | 
40 | #endif  // DISTNTF_DISTNTFCPALS_HPP_
41 | 


--------------------------------------------------------------------------------
/distntf/distntfmu.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright Ramakrishnan Kannan 2018 */
 2 | 
 3 | #ifndef DISTNTF_DISTNTFMU_HPP_
 4 | #define DISTNTF_DISTNTFMU_HPP_
 5 | 
 6 | #include "distntf/distauntf.hpp"
 7 | 
 8 | namespace planc {
 9 | 
10 | class DistNTFMU : public DistAUNTF {
11 |  protected:
12 |  /**
13 |    * This is MU update function.
14 |    * Given the MTTKRP and the hadamard of all the grams, we 
15 |    * determine the factor matrix to be updated. 
16 |    * @param[in] Mode of the factor to be updated
17 |    * @returns The new updated factor
18 |    */
19 |   MAT update(const int mode) {
20 |     MAT H(this->m_local_ncp_factors.factor(mode));
21 |     if (m_nls_sizes[mode] > 0) {
22 |       MAT temp = H * this->global_gram + EPSILON;
23 |       MAT rhs = this->ncp_local_mttkrp_t[mode].t();
24 |       H = (H % rhs) / temp;
25 |     } else {  // Return unmodified factor
26 |       H.zeros();
27 |     }
28 |     return H.t();
29 |   }
30 | 
31 |  public:
32 |   DistNTFMU(const Tensor &i_tensor, const int i_k, algotype i_algo,
33 |             const UVEC &i_global_dims, const UVEC &i_local_dims,
34 |             const UVEC &i_nls_sizes, const UVEC &i_nls_idxs,
35 |             const NTFMPICommunicator &i_mpicomm)
36 |       : DistAUNTF(i_tensor, i_k, i_algo, i_global_dims, i_local_dims,
37 |                   i_nls_sizes, i_nls_idxs, i_mpicomm) {}
38 | };  // class DistNTFMU
39 | 
40 | }  // namespace planc
41 | 
42 | #endif  // DISTNTF_DISTNTFMU_HPP_
43 | 


--------------------------------------------------------------------------------
/utilities/splitfiles.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | #It splits the dense matrix into row splits and column splits
 3 | #Every file will have equal number of lines in Arows_#cores_idx
 4 | #and equal columsn in Acols_#cores_idx
 5 | #Run as : splitfiles.sh filename filenamet #cores
 6 | numCores=$3
 7 | totalLines=$(wc -l < $1)
 8 | #totalLines=
 9 | numLines=$(( $totalLines / $numCores ))
10 | outputdir=${numCores}cores
11 | rm -rf $outputdir
12 | mkdir $outputdir
13 | #------------------------------
14 | #row split
15 | split -a 3 -d -l ${numLines} $1 $outputdir/Arows_${numCores}_
16 | 
17 | #rename the file suffixes with numbers
18 | i=0
19 | for file in $outputdir/Arows_*
20 | do
21 |   mv $file $outputdir/Arows_${numCores}_${i}
22 |   i=$(( i + 1 ))
23 | done
24 | 
25 | totalLines=$(wc -l < $2)
26 | #totalLines=115200
27 | numLines=$(( $totalLines / $numCores ))
28 | #------------------------------
29 | #row split
30 | split -a 3 -d -l ${numLines} $2 $outputdir/Acols_${numCores}_
31 | 
32 | #rename the file suffixes with numbers
33 | i=0
34 | for file in $outputdir/Acols_*
35 | do
36 |   mv $file $outputdir/Acols_${numCores}_${i}
37 |   i=$(( i + 1 ))
38 | done
39 | #-------------------------------
40 | #column split
41 | #numCols=$(gawk -F' ' '{print NF; exit}' $1)
42 | #perCol=$(( ${numCols} / ${numCores} ))
43 | #for ((i=0;i<numCores;i++ ))
44 | #do
45 |   #j=$((i+1))
46 |   #cut -f$((((${i}*${perCol})+1)))-$((((${i}+1)*${perCol}))) -d " " $1 >> ${outputdir}/Acols_${numCores}_$i 2>&1
47 | #done
48 | #-------------------------------------


--------------------------------------------------------------------------------
/ntf/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #Copyright 2016 Ramakrishnan Kannan
 2 | 
 3 | cmake_minimum_required(VERSION 3.6 FATAL_ERROR)
 4 | 
 5 | set(ARMA_USE_WRAPPER true)
 6 | 
 7 | # the settings below will be automatically configured by the rest of this script
 8 | 
 9 | project(NTF CXX)
10 | set(NTFLIB_COMMON ${NTF_SOURCE_DIR}/../common)
11 | set(NNLS_SRC ${NTF_SOURCE_DIR}/../nnls/)
12 | message(STATUS "NTF_SOURCE_DIR =  ${NTF_SOURCE_DIR}")
13 | message(STATUS "NTFLIB_COMMON =  ${NTFLIB_COMMON}")
14 | 
15 | include(${NTFLIB_COMMON}/cmake_aux/NMFLIB_FindARMA.cmake)
16 | 
17 | message(STATUS "CMAKE_CXX_FLAGS           = ${CMAKE_CXX_FLAGS}"          )
18 | message(STATUS "CMAKE_SHARED_LINKER_FLAGS = ${CMAKE_SHARED_LINKER_FLAGS}")
19 | message(STATUS "CMAKE_REQUIRED_INCLUDES   = ${CMAKE_REQUIRED_INCLUDES}"  )
20 | 
21 | message(STATUS "*** libraries:")
22 | message(STATUS "*** NTFLIB_LIBS = ${NTFLIB_LIBS} ${NMFLIB_LIBS}")
23 | 
24 | add_definitions(-fopenmp)
25 | 
26 | include_directories(
27 |   ${ARMADILLO_INCLUDE_DIR}
28 |   ${ARMADILLO_INCLUDE_DIRS}
29 |   ${NTF_SOURCE_DIR}
30 |   ${NTF_SOURCE_DIR}/../
31 |   ${NTFLIB_COMMON}
32 |   ${NNLS_SRC}
33 |   ${Boost_INCLUDE_DIR}
34 |   ${MKL_INCLUDE_DIR}
35 |   ${OPENBLAS_INCLUDE_DIR}
36 | )
37 | 
38 | add_executable(dense_ntf
39 | ntf.cpp
40 | )
41 | 
42 | target_link_libraries(dense_ntf ${NTFLIB_LIBS} ${NMFLIB_LIBS})
43 | install(TARGETS dense_ntf
44 |         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
45 |         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
46 |         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )


--------------------------------------------------------------------------------
/nmf/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #Copyright 2016 Ramakrishnan Kannan
 2 | 
 3 | cmake_minimum_required(VERSION 3.6 FATAL_ERROR)
 4 | 
 5 | set(ARMA_USE_WRAPPER true)
 6 | 
 7 | # the settings below will be automatically configured by the rest of this script
 8 | 
 9 | project(NMF CXX)
10 | set(NMFLIB_COMMON ${NMF_SOURCE_DIR}/../common)
11 | set(NNLS_SRC ${NMF_SOURCE_DIR}/../nnls/)
12 | message(STATUS "NMF_SOURCE_DIR =  ${NMF_SOURCE_DIR}")
13 | message(STATUS "NMFLIB_COMMON =  ${NMFLIB_COMMON}")
14 | 
15 | include(${NMFLIB_COMMON}/cmake_aux/NMFLIB_FindARMA.cmake)
16 | 
17 | message(STATUS "CMAKE_CXX_FLAGS           = ${CMAKE_CXX_FLAGS}"          )
18 | message(STATUS "CMAKE_SHARED_LINKER_FLAGS = ${CMAKE_SHARED_LINKER_FLAGS}")
19 | message(STATUS "CMAKE_REQUIRED_INCLUDES   = ${CMAKE_REQUIRED_INCLUDES}"  )
20 | 
21 | message(STATUS "*** libraries:")
22 | message(STATUS "*** NMFLIB_LIBS = ${NMFLIB_LIBS}")
23 | 
24 | include_directories(
25 |   ${ARMADILLO_INCLUDE_DIR}
26 |   ${ARMADILLO_INCLUDE_DIRS}
27 |   ${NMF_SOURCE_DIR}
28 |   ${NMF_SOURCE_DIR}/../
29 |   ${NMFLIB_COMMON}
30 |   ${NNLS_SRC}
31 |   ${Boost_INCLUDE_DIR}
32 |   ${MKL_INCLUDE_DIR}
33 |   ${OPENBLAS_INCLUDE_DIR}
34 | )
35 | 
36 | if(CMAKE_BUILD_SPARSE)
37 |   set(DENSE_OR_SPARSE sparse)
38 | else()
39 |   set(DENSE_OR_SPARSE dense)
40 | endif()
41 | 
42 | add_executable(${DENSE_OR_SPARSE}_nmf nmf.cpp)
43 | target_link_libraries(${DENSE_OR_SPARSE}_nmf ${NMFLIB_LIBS})
44 | install(TARGETS ${DENSE_OR_SPARSE}_nmf
45 |         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
46 |         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
47 |         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )


--------------------------------------------------------------------------------
/utilities/partitioner/run_partitioner.py:
--------------------------------------------------------------------------------
 1 | # EXAMPLE: python3 run_partitioner.py configs/partition_configs.json example_partition
 2 | 
 3 | import subprocess as sb         #for running PLANC
 4 | import sys
 5 | from scipy.io import mmread
 6 | import json
 7 | import numpy as np
 8 | from scipy import sparse
 9 | from planc_partitioner import planc_partitioner
10 | 
11 | config_path = sys.argv[1]
12 | f = open(config_path)
13 | config = json.load(f)
14 | f.close()
15 | 
16 | id = sys.argv[2]
17 | c = config[id][0]
18 | 
19 | print("config type: " + str(type(config)))
20 | print(list(config.keys()))
21 | 
22 | print(id)
23 | print(c)
24 | 
25 | print(c['format'])
26 | 
27 | # partition feature matrix... ----> writing new partition function
28 | test = planc_partitioner() 
29 | output_path = c['partitioner_output_path'] if ('partitioner_output_path' in c) else c['feature_mat_path']
30 | 
31 | # automatically create output directory...
32 | sb.run("mkdir " + output_path, shell=True)
33 | 
34 | # read in dataset ----> mm stands for matrix market format...
35 | if c['format'] == "mm" :
36 |     print("reading feature matrix in matrix market format")
37 |     A = mmread(c['feature_mat_path'])
38 |     m = A.shape[0]
39 |     n = A.shape[1]
40 |     print(type(A))
41 |     print(A)
42 | 
43 |     test.partition(c['feature_mat_path'], output_path, A,m,n,c['pr'], c['pc'])
44 | # elif c['format'] == "bin" :
45 | #     print("reading feature matrix in binary format")
46 | #     mat = np.fromfile(c['feature_mat_path'])
47 | #     m = c['m']
48 | #     n = c['n']
49 | 
50 | #     print(type(A))
51 | #     print(A)
52 | 
53 | #     test.partition(output_path, A,m,n,c['pr'], c['pc'])
54 | 


--------------------------------------------------------------------------------
/common/ntf_utils.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright 2017 Ramakrishnan Kannan */
 2 | 
 3 | #ifndef COMMON_NTF_UTILS_HPP_
 4 | #define COMMON_NTF_UTILS_HPP_
 5 | 
 6 | #include "common/ncpfactors.hpp"
 7 | #include "common/tensor.hpp"
 8 | 
 9 | /**
10 |  * Returns the khatri-rao product between two matrices.
11 |  * @param[in] A is of size m x k matrix
12 |  * @param[in]  B is of size n x k
13 |  * @param[out] Returns C of size mn x k
14 |  */
15 | void khatrirao(const MAT &i_A, const MAT &i_B, MAT *o_C) {
16 |   assert(i_A.n_cols == i_B.n_cols);
17 |   VEC acol = arma::zeros<VEC>(i_A.n_rows);
18 |   VEC bcol = arma::zeros<VEC>(i_B.n_rows);
19 |   for (unsigned int i = 0; i < i_A.n_cols; i++) {
20 |     acol = i_A.col(i);
21 |     bcol = i_B.col(i);
22 |     for (unsigned int j = 0; j < acol.n_rows; j++) {
23 |       (*o_C)(arma::span(j * bcol.n_rows, (j + 1) * bcol.n_rows - 1), i) =
24 |           acol(j) * bcol;
25 |     }
26 |   }
27 | }
28 | /**
29 |  * Returns the kronecker product between two vectors
30 |  * @param[in] acol column vector of size m
31 |  * @param[in] bcol is column vector of size n
32 |  * @param[out] output vector of size mn
33 |  */
34 | inline void kronecker(const VEC &i_acol, const VEC &i_bcol, VEC *o_c) {
35 |   for (unsigned int j = 0; j < i_acol.n_rows; j++) {
36 |     (*o_c).rows(arma::span(j * i_bcol.n_rows, (j + 1) * i_bcol.n_rows - 1)) =
37 |         i_acol(j) * i_bcol;
38 |   }
39 | }
40 | /**
41 |  * Return the mttkrp of mode i_n of tensor X. That is., determine
42 |  * the KRP leaving out i_n and multiply with mode i_n factor
43 |  * @param[in] mode i_n
44 |  * @param[in] Tensor X
45 |  * @param[in] NCPFactors
46 |  * @param[out] MTTKRP of factor mode i_n 
47 |  */
48 | 
49 | void mttkrp(const int i_n, const planc::Tensor &X, planc::NCPFactors &i_F,
50 |             MAT *o_mttkrp) {
51 |   MAT krp = i_F.krp_leave_out_one(i_n);
52 |   X.mttkrp(i_n, krp, o_mttkrp);
53 | }
54 | 
55 | #endif // COMMON_NTF_UTILS_HPP_
56 | 


--------------------------------------------------------------------------------
/distntf/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #Copyright 2016 Ramakrishnan Kannan
 2 | 
 3 | cmake_minimum_required(VERSION 3.6 FATAL_ERROR)
 4 | 
 5 | set(ARMA_USE_WRAPPER true)
 6 | 
 7 | # the settings below will be automatically configured by the rest of this script
 8 | 
 9 | project(DISTNTF CXX)
10 | set(NMFLIB_COMMON ${DISTNTF_SOURCE_DIR}/../common)
11 | set(NNLS_SRC ${DISTNTF_SOURCE_DIR}/../nnls/)
12 | message(STATUS "DISTNTF_SOURCE_DIR =  ${DISTNTF_SOURCE_DIR}")
13 | message(STATUS "NMFLIB_COMMON =  ${NMFLIB_COMMON}")
14 | 
15 | include(${NMFLIB_COMMON}/cmake_aux/NMFLIB_FindARMA.cmake)
16 | 
17 | add_definitions(-DMPI_DISTNTF=1)
18 | add_definitions(-fopenmp)
19 | 
20 | find_package(MPI REQUIRED)
21 | 
22 | message(STATUS "   Boost_FOUND = ${Boost_FOUND}"   )
23 | message(STATUS " MPI_CXX_FOUND = ${MPI_CXX_FOUND}" )
24 | 
25 | if(MPI_CXX_FOUND)
26 |   set(NMFLIB_LIBS ${NMFLIB_LIBS} ${MPI_CXX_LIBRARIES})
27 | endif()
28 | 
29 | message(STATUS "CMAKE_CXX_FLAGS           = ${CMAKE_CXX_FLAGS}"          )
30 | message(STATUS "CMAKE_SHARED_LINKER_FLAGS = ${CMAKE_SHARED_LINKER_FLAGS}")
31 | message(STATUS "CMAKE_REQUIRED_INCLUDES   = ${CMAKE_REQUIRED_INCLUDES}"  )
32 | 
33 | message(STATUS "")
34 | message(STATUS "*** libraries:")
35 | message(STATUS "*** NMFLIB_LIBS = ${NMFLIB_LIBS}")
36 | message(STATUS "")
37 | 
38 | include_directories(
39 |   ${ARMADILLO_INCLUDE_DIR}
40 |   ${ARMADILLO_INCLUDE_DIRS}
41 |   ${DISTNTF_SOURCE_DIR}
42 |   ${DISTNTF_SOURCE_DIR}/../
43 |   ${NMFLIB_COMMON}
44 |   ${NNLS_SRC}
45 |   ${MPI_CXX_INCLUDE_PATH}
46 |   ${Boost_INCLUDE_DIR}
47 |   ${MKL_INCLUDE_DIR}
48 |   ${OPENBLAS_INCLUDE_DIR}
49 | )
50 | 
51 | add_executable(dense_distntf
52 |   distntf.cpp
53 | )
54 | 
55 | target_link_libraries(dense_distntf ${NMFLIB_LIBS})
56 | install(TARGETS dense_distntf
57 |         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
58 |         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
59 |         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )


--------------------------------------------------------------------------------
/nmf/sampletest.cpp:
--------------------------------------------------------------------------------
 1 | /* Copyright 2016 Ramakrishnan Kannan */
 2 | 
 3 | void testSmall() {
 4 |   fmat A, W, H;
 5 |   A.load("/scratch/ramki/datasets/xdata/bpp/A_rnd.csv");
 6 |   BPPNMF<fmat> bppnmf2(A, 5);
 7 |   INFO << "completed constructor" << endl;
 8 |   double t1 = omp_get_wtime();
 9 |   bppnmf2.computeNMF();
10 |   double t2 = omp_get_wtime();
11 |   OUTPUT << bppnmf2.getLeftLowRankFactor() << endl;
12 |   OUTPUT << bppnmf2.getRightLowRankFactor() << endl;
13 |   INFO << "Computed Fast NMF with multiple RHS!!!:"
14 |        << norm((A - bppnmf2.getLeftLowRankFactor() *
15 |                         bppnmf2.getRightLowRankFactor().t()),
16 |                "fro")
17 |        << endl;
18 |   INFO << "time taken:" << (t2 - t1) << endl;
19 | }
20 | 
21 | void testLowRank() {
22 |   fmat A, W, H;
23 |   W.load("/scratch/ramki/datasets/xdata/bpp/w_lr_init.csv");
24 |   H.load("/scratch/ramki/datasets/xdata/bpp/h_lr_init.csv");
25 |   W = W.rows(0, 50000);
26 |   H = H.rows(0, 100000);
27 |   INFO << "compled loading the matrices W.m=" << W.n_rows << " W.n=" << W.n_cols
28 |        << " H.m=" << H.n_rows << " H.n=" << H.n_cols << endl;
29 |   A = W * H.t();
30 |   INFO << "created input matrix m=" << A.n_rows << " n=" << A.n_cols << endl;
31 |   BPPNMF<fmat> bppnmf2(A, 100);
32 |   INFO << "completed constructor" << endl;
33 |   double t1 = omp_get_wtime();
34 |   bppnmf2.computeNMF();
35 |   double t2 = omp_get_wtime();
36 |   INFO << "Computed Fast NMF with multiple RHS!!!:"
37 |        << norm((A - bppnmf2.getLeftLowRankFactor() *
38 |                         bppnmf2.getRightLowRankFactor().t()),
39 |                "fro")
40 |        << endl;
41 |   INFO << "time taken:" << (t2 - t1) << endl;
42 |   bppnmf2.getLeftLowRankFactor().save(
43 |       "/scratch/ramki/datasets/xdata/bpp/w_lr_bpp_output.csv", raw_ascii);
44 |   bppnmf2.getRightLowRankFactor().save(
45 |       "/scratch/ramki/datasets/xdata/bpp/h_lr_bpp_output.csv", raw_ascii);
46 | }
47 | 


--------------------------------------------------------------------------------
/jointnmf/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #Copyright 2022 Ramakrishnan Kannan
 2 | 
 3 | cmake_minimum_required(VERSION 3.6 FATAL_ERROR)
 4 | 
 5 | set(ARMA_USE_WRAPPER true)
 6 | 
 7 | # the settings below will be automatically configured by the rest of this script
 8 | 
 9 | project(NMF CXX)
10 | set(NMFLIB_COMMON ${NMF_SOURCE_DIR}/../common)
11 | set(NNLS_SRC ${NMF_SOURCE_DIR}/../nnls/)
12 | message(STATUS "NMF_SOURCE_DIR =  ${NMF_SOURCE_DIR}")
13 | message(STATUS "NMFLIB_COMMON =  ${NMFLIB_COMMON}")
14 | 
15 | include(${NMFLIB_COMMON}/cmake_aux/NMFLIB_FindARMA.cmake)
16 | 
17 | message(STATUS "CMAKE_CXX_FLAGS           = ${CMAKE_CXX_FLAGS}"          )
18 | message(STATUS "CMAKE_SHARED_LINKER_FLAGS = ${CMAKE_SHARED_LINKER_FLAGS}")
19 | message(STATUS "CMAKE_REQUIRED_INCLUDES   = ${CMAKE_REQUIRED_INCLUDES}"  )
20 | 
21 | message(STATUS "*** libraries:")
22 | message(STATUS "*** NMFLIB_LIBS = ${NMFLIB_LIBS}")
23 | 
24 | include_directories(
25 |   ${ARMADILLO_INCLUDE_DIR}
26 |   ${ARMADILLO_INCLUDE_DIRS}
27 |   ${NMF_SOURCE_DIR}
28 |   ${NMF_SOURCE_DIR}/../
29 |   ${NMFLIB_COMMON}
30 |   ${NNLS_SRC}
31 |   ${Boost_INCLUDE_DIR}
32 |   ${MKL_INCLUDE_DIR}
33 |   ${OPENBLAS_INCLUDE_DIR}
34 | )
35 | 
36 | if(CMAKE_BUILD_SPDEN)
37 |   add_definitions(-DBUILD_SPDEN=1)
38 |   set(JNMF_TYPE spden_)
39 | elseif(CMAKE_BUILD_DENSP)
40 |   add_definitions(-DBUILD_DENSP=1)
41 |   set(JNMF_TYPE densp_)
42 | elseif(CMAKE_BUILD_DENDEN)
43 |   add_definitions(-DBUILD_DENDEN=1)
44 |   set(JNMF_TYPE denden_)
45 | elseif(CMAKE_BUILD_SPSP)
46 |   add_definitions(-DBUILD_SPSP=1)
47 |   set(JNMF_TYPE spsp_)
48 | else()
49 |   set(JNMF_TYPE)
50 | endif()
51 | 
52 | add_executable(${JNMF_TYPE}jointnmf jointnmf.cpp jointnmf_driver.hpp)
53 | target_link_libraries(${JNMF_TYPE}jointnmf ${NMFLIB_LIBS})
54 | install(TARGETS ${JNMF_TYPE}jointnmf
55 |         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
56 |         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
57 |         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )
58 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.6 FATAL_ERROR)
 2 | 
 3 | # the settings below will be automatically configured by the rest of this script
 4 | 
 5 | project(PLANC CXX)
 6 | set(PLANC_MAJOR_VERSION 0)
 7 | set(PLANC_MINOR_VERSION 8)
 8 | set(PLANC_PATCH_VERSION 1)
 9 | set(PLANC_VERSION "${PLANC_MAJOR_VERSION}.${PLANC_MINOR_VERSION}.${PLANC_PATCH_VERSION}")
10 | 
11 | # Adhere to GNU filesystem layout conventions
12 | include(GNUInstallDirs)
13 | include(CMakePackageConfigHelpers)
14 | 
15 | set(CMAKE_CXX_STANDARD 11)
16 | cmake_host_system_information(RESULT _host_name QUERY FQDN)
17 | 
18 | message(STATUS, "host name = ${_host_name}")
19 | 
20 | string(FIND ${_host_name} "rhea" RHEA_FOUND)
21 | string(FIND ${_host_name} "eos" EOS_FOUND)
22 | string(FIND ${_host_name} "titan" TITAN_FOUND)
23 | string(FIND ${_host_name} "summit" SUMMIT_FOUND)
24 | 
25 | message(STATUS, "RHEA = ${RHEA_FOUND}")
26 | message(STATUS, "EOS = ${EOS_FOUND}")
27 | message(STATUS, "TITAN = ${TITAN_FOUND}")
28 | message(STATUS, "SUMMIT = ${SUMMIT_FOUND}")
29 | 
30 | if(NOT (TITAN_FOUND EQUAL -1 AND SUMMIT_FOUND EQUAL -1))
31 |     set(CMAKE_BUILD_CUDA 1)
32 | endif()
33 | 
34 | set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
35 | set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
36 | 
37 | set(NMF_SOURCE_DIR ${PROJECT_SOURCE_DIR}/nmf)
38 | set(NTF_SOURCE_DIR ${PROJECT_SOURCE_DIR}/ntf)
39 | set(DISTNMF_SOURCE_DIR ${PROJECT_SOURCE_DIR}/distnmf)
40 | set(DISTNTF_SOURCE_DIR ${PROJECT_SOURCE_DIR}/distntf)
41 | set(HIERNMF_SOURCE_DIR ${PROJECT_SOURCE_DIR}/hiernmf)
42 | 
43 | set(DENSEDIRS nmf distnmf distntf hiernmf)
44 | set(SPARSEDIRS nmf distnmf hiernmf)
45 | 
46 | set(CMAKE_BUILD_SPARSE 0)
47 | foreach (DENSEDIR ${DENSEDIRS})
48 |   add_subdirectory(${DENSEDIR} dense_${DENSEDIR})
49 | endforeach()
50 |   
51 | set(CMAKE_BUILD_SPARSE 1)
52 | set(CMAKE_BUILD_CUDA 0)
53 | foreach (SPARSEDIR ${SPARSEDIRS})
54 |   add_subdirectory(${SPARSEDIR} sparse_${SPARSEDIR})
55 | endforeach()


--------------------------------------------------------------------------------
/distntf/distntfhals.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright Ramakrishnan Kannan 2018 */
 2 | 
 3 | #ifndef DISTNTF_DISTNTFHALS_HPP_
 4 | #define DISTNTF_DISTNTFHALS_HPP_
 5 | 
 6 | #include "distntf/distauntf.hpp"
 7 | 
 8 | namespace planc {
 9 | 
10 | class DistNTFHALS : public DistAUNTF {
11 |  protected:
12 |    /**
13 |    * This is HALS update function.
14 |    * Given the MTTKRP and the hadamard of all the grams, we 
15 |    * determine the factor matrix to be updated. 
16 |    * @param[in] Mode of the factor to be updated
17 |    * @returns The new updated factor
18 |    */
19 |   MAT update(const int mode) {
20 |     MAT H(this->m_local_ncp_factors.factor(mode));
21 |     // iterate over all columns of H
22 |     for (int i = 0; i < this->m_local_ncp_factors.rank(); i++) {
23 |       VEC updHi;
24 |       if (m_nls_sizes[mode] > 0) {
25 |         updHi = H.col(i) + ((this->ncp_local_mttkrp_t[mode].row(i)).t() -
26 |                             H * this->global_gram.col(i));
27 |       } else {
28 |         updHi = H.col(i);
29 |         updHi.zeros();
30 |       }
31 | 
32 |       fixNumericalError<VEC>(&updHi, EPSILON_1EMINUS16, EPSILON_1EMINUS16);
33 |       double normHi = arma::norm(updHi, 2);
34 |       normHi *= normHi;
35 |       double globalnormHi = normHi;
36 |       MPI_Allreduce(&normHi, &globalnormHi, 1, MPI_DOUBLE, MPI_SUM,
37 |                     MPI_COMM_WORLD);
38 |       if (globalnormHi > 0) {
39 |         H.col(i) = updHi;
40 |       }
41 |     }
42 |     return H.t();
43 |   }
44 | 
45 |  public:
46 |   DistNTFHALS(const Tensor &i_tensor, const int i_k, algotype i_algo,
47 |               const UVEC &i_global_dims, const UVEC &i_local_dims,
48 |               const UVEC &i_nls_sizes, const UVEC &i_nls_idxs,
49 |               const NTFMPICommunicator &i_mpicomm)
50 |       : DistAUNTF(i_tensor, i_k, i_algo, i_global_dims, i_local_dims,
51 |                   i_nls_sizes, i_nls_idxs, i_mpicomm) {}
52 | };  // class DistNTFHALS
53 | 
54 | }  // namespace planc
55 | 
56 | #endif  // DISTNTF_DISTNTFHALS_HPP_
57 | 


--------------------------------------------------------------------------------
/utilities/partitioner/planc_output_convert.py:
--------------------------------------------------------------------------------
 1 | # Copyright Benjamin Cobb 2022
 2 | # NOTE: the goal of this script is to convert planc output to either .txt, .mtx, or .npz formats
 3 | import numpy as np
 4 | import scipy
 5 | from scipy.io import mmwrite
 6 | import sys
 7 | import os
 8 | 
 9 | # USAGE: python3 planc_output_convert.py path_to_planc_output converted_output_path conversion_format m n k
10 | # python3 planc_output_convert.py ./test_data/output/11_9_test_10_2_2 ./test_data/converted/ npz 11 9 2
11 | 
12 | try:
13 |     planc_output_path = sys.argv[1]
14 |     converted_output_path = sys.argv[2]
15 |     conversion_format = sys.argv[3]
16 |     m = int(sys.argv[4])
17 |     n = int(sys.argv[5])
18 |     k = int(sys.argv[6])
19 | except:
20 |     print('USAGE:   python3 planc_output_convert.py path_to_planc_output converted_output_path conversion_format m n k')
21 |     print('EXAMPLE: python3 planc_output_convert.py ./test_data/output/11_9_test_10_2_2 ./test_data/converted/ npz 11 9 2')
22 |     exit()
23 | 
24 | W_path = planc_output_path + '_W'
25 | H_path = planc_output_path + '_H'
26 | print(W_path)
27 | print(H_path)
28 | 
29 | prefix = converted_output_path + os.path.basename(planc_output_path)
30 | W_converted = prefix + '_W'
31 | H_converted = prefix + '_H'
32 | print('prefix: ' + prefix)
33 | print(W_converted)
34 | print(H_converted)
35 | 
36 | # NOTE: is float64 the correct data-type?...
37 | W = np.fromfile(W_path, 'float64')
38 | W = np.asmatrix(W).reshape(k, m)
39 | 
40 | 
41 | H = np.fromfile(H_path, 'float64')
42 | H = np.asmatrix(H).reshape(k,n)
43 | 
44 | if conversion_format == "mtx":
45 |     pass
46 |     mmwrite(W_converted, W)
47 |     mmwrite(H_converted, H)
48 | elif conversion_format == "txt":
49 |     pass
50 |     np.savetxt(W_converted + '.txt', W)
51 |     np.savetxt(H_converted + '.txt', H)
52 | elif conversion_format == "npz":
53 |     pass
54 |     np.savez(W_converted, W)
55 |     np.savez(H_converted, H)
56 | else:
57 |     print('conversion format not recognized, options are: mtx, txt, and npz')


--------------------------------------------------------------------------------
/dimtree/dimtrees.h:
--------------------------------------------------------------------------------
 1 | /* Copyright Koby Hayashi 2018 */
 2 | 
 3 | #ifndef DIMTREE_DIMTREES_H_
 4 | #define DIMTREE_DIMTREES_H_
 5 | 
 6 | #include "dimtree/ddttensor.h"
 7 | 
 8 | /**
 9 |   This .h file contains all the functions need to construct dimension
10 |   trees for fast_CP_ALS algorithms.
11 | */
12 | 
13 | /**
14 |   Enumerator for denoting desired output formats
15 | */
16 | typedef enum { RowMajor, ColMajor } Output_Layout;
17 | 
18 | /**
19 |   Partial MTTKRP functions
20 | */
21 | 
22 | void partial_MTTKRP(Output_Layout OL, long int s, direction D, tensor *T,
23 |                     double *A, long int r, double *C, long int num_threads);
24 | void partial_MTTKRP_with_KRP(Output_Layout OL, long int s, direction D,
25 |                              ktensor *Y, tensor *T, double *C,
26 |                              long int num_threads);
27 | void partial_MTTKRP_with_KRP_output_FM(direction D, ktensor *Y, tensor *T,
28 |                                        long int num_threads);
29 | void partial_MTTKRP_with_KRP_output_T(long int s, direction D,
30 |                                       ktensor *input_ktensor,
31 |                                       tensor *input_tensor,
32 |                                       tensor *output_tensor,
33 |                                       long int num_threads);
34 | 
35 | void multi_TTV(Output_Layout OL, long int s, direction D, tensor *T, double *A,
36 |                long int r, double *C, long int num_threads);
37 | void multi_TTV_with_KRP(Output_Layout OL, long int s, direction D, tensor *T,
38 |                         ktensor *Y, double *C, long int num_threads);
39 | void multi_TTV_with_KRP_output_FM(direction D, tensor *input_tensor,
40 |                                   ktensor *input_ktensor, long int num_threads);
41 | void multi_TTV_with_KRP_output_T(long int s, direction D, tensor *input_tensor,
42 |                                  ktensor *input_ktensor, tensor *output_tensor,
43 |                                  long int num_threads);
44 | #endif  // DIMTREE_DIMTREES_H_
45 | 


--------------------------------------------------------------------------------
/utilities/processstackexchange.txt:
--------------------------------------------------------------------------------
 1 | Processing posts.xml
 2 | ------------------
 3 | . Extract Body of all questions - xmllint --xpath "/posts/row[@PostTypeId=\"1\"]/@Body" posts.xml >> questionbody.txt 2>&1
 4 | . Very big instead of  xmllint use "grep 'PostTypeId=\"1\"' test.xml | grep -o -P '(?<=Body=\").*(?=OwnerUserId)'"
 5 | . introduce record end indicator using sed. When we use html2text, w3m or recode it removes \n and we loose record ends. grep 'PostTypeId=\"1\"' test.xml | grep -o -P '(?<=Body=\").*(?=OwnerUserId)' | sed ':a;N;$!ba;s/\n/55RECORDEND66\n/g' 
 6 | . Remove &lt; and &gt; from questionbody.txt using vi or sed. sed -e 's/\p*&lt\;p*//g' questionbody.txt | sed -e 's/\p*&gt\;p*//g'
 7 | . Remove and replace #xA;, #xD; & etc. sed 's/&#*xA;//g' |sed 's/&#*xD;//g' 
 8 | . Remove http:// urls from questionbody4.txt sed 's/http[^[:space:]]*//g' questionbody4.txt >> questionbody5.txt
 9 | all the above together sed 's/\p*&lt\;p*//g' | sed 's/\p*&gt\;p*//g' | sed 's/&xA;//g' |sed 's/&#xD;//g' | sed 's/http[^[:space:]]*//g'
10 | . Remove html entitites from questionbody.txt (right combination recode then sed) using html2text
11 | . Remove empty lines introduced by <p> tag in html using sed. sed ':a;N;$!ba;s/\n//g'
12 | . Remove latex tags. Use detex questionbody5.txt >> questionbody6.txt 2>&1. Something wrong with this. Don't do this now. But use the above sed to remove.
13 | . Remove stop words and stem using nltk tool kit and the pythonscript.  
14 | 
15 | One command for entire script 
16 | 
17 | grep 'PostTypeId=\"1\"' test.xml | grep -o -P '(?<=Body=\").*(?=OwnerUserId)' | sed ':a;N;$!ba;s/\n/55RECORDEND66\n/g' | sed 's/\p*&lt\;p*//g' | sed 's/\p*&gt\;p*//g' | sed 's/&#*xA;//g' |sed 's/&#*xD;//g' | sed 's/http[^[:space:]]*//g' | html2text | sed ':a;N;$!ba;s/\n//g' | sed 's/55RECORDEND66/\n/g'
18 | 
19 | clean up strings
20 | &quot
21 | /li
22 | /ol
23 | /ul
24 | /code
25 | /strong
26 | /em
27 | href=
28 | &amp
29 | Example : 
30 | cat testquestionbody.txt | sed 's/\/li//g' | sed 's/\/ul//g' | sed 's/href-//g' | sed 's/\&quot\;//g' | sed 's/\/code//g' | sed 's/\/strong//g' | sed 's/\&amp//g' | sed 's/;*#[0-9,A-Z,a-z]*;//g' | sed 's/55RECORDEND66//g'


--------------------------------------------------------------------------------
/utilities/permute-sparse-struct.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstdlib>
 3 | #include <vector>
 4 | #include <ctime>
 5 | 
 6 | int main(int argc, char **argv)
 7 | {
 8 |   printf("permute-sparse-struct began.\n");
 9 |   if (argc < 3) {
10 |     printf("Usage: permute-sparse-struct [sparse-struct-file-name] [permuted-file-name]\n");
11 |     return 0;
12 |   }
13 | 
14 |   FILE *file = fopen(argv[1], "r");
15 |   if (file == NULL) { 
16 |     printf("Unable to open file %s.\n", argv[1]);
17 |     return 0;
18 |   }
19 |   int order, nnz;
20 |   printf("Reading the sparse struct...\n");
21 |   fscanf(file, " %d %d", &order, &nnz);
22 |   std::vector<int> dimSize(order);
23 |   std::vector< std::vector<int> > idx(order);
24 |   std::vector<double> val;
25 |   for (int i = 0; i < order; i++) { fscanf(file, " %d", &dimSize[i]); }
26 |   for (int i = 0; i < order; i++) { idx[i].resize(nnz); }
27 |   val.resize(nnz);
28 |   for (int i = 0; i < nnz; i++) {
29 |     for (int j = 0; j < order; j++) { 
30 |       fscanf(file, " %d", &idx[j][i]); idx[j][i]--; // Convert to 0-based
31 |     }
32 |     fscanf(file, " %lf", &val[i]);
33 |   }
34 |   fclose(file);
35 |   std::vector< std::vector<int> > perm(order);
36 |   printf("Permuting the sparse struct...\n");
37 |   srand((int)time(0));
38 |   for (int i = 0; i < order; i++) {
39 |     perm[i].resize(dimSize[i]);
40 |     for (int j = 0; j < dimSize[i]; j++) { perm[i][j] = j; }
41 |     for (int j = 0; j < dimSize[i]; j++) { std::swap(perm[i][j], perm[i][rand() % dimSize[i]]); }
42 |   }
43 |   printf("Writing the permuted sparse struct...\n");
44 |   file = fopen(argv[2], "w");
45 |   if (file == NULL) { 
46 |     printf("Unable to open file %s.\n", argv[2]);
47 |     return 0;
48 |   }
49 |   fprintf(file, "%d %d\n", order, nnz);
50 |   for (int i = 0; i < order; i++) { fprintf(file, "%d ", dimSize[i]); }
51 |   for (int i = 0; i < nnz; i++) {
52 |     fprintf(file, "\n");
53 |     for (int j = 0; j < order; j++) { fprintf(file, "%d ", perm[j][idx[j][i]] + 1); }
54 |     fprintf(file, "%e", val[i]);
55 |   }
56 |   fclose(file);
57 | 
58 |   printf("permute-sparse-struct finished.\n");
59 |   return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/utilities/README.md:
--------------------------------------------------------------------------------
 1 | In this directory, I provide the sample small utilities to build the real world datasets.
 2 | 
 3 | 1. 1D Split of Dense Data - Have a space separated matrix and its transpose in the same directory. Run 
 4 | ````splitfiles.sh filename filenamet #cores```` 
 5 | The above command will generate appropriate directories and dump the 1D distribution of the matrix.
 6 | 2. 2D Split of Dense data - Have a space separated matrix alone. You DON'T need the matrix transpose.
 7 | Run ````splitfiles.sh filename filenamet #cores````. 
 8 | The above command will prepare the data that can be given as input to the nmf program.
 9 | 3. 1D or 2D split of sparse file - The input file must be in coordinate format with zero indexing.
10 | That is the index starts with zero. To run this command, first your have to build SplitFiles.cpp.
11 | A sample build file is provided as buildsplitfiles.sh. 
12 | 
13 | ````
14 | Usage 1 : SplitFiles inputmtxfile outputdirectory numsplits [pr=1] [pc=1]
15 | Usage 2 : SplitFiles m n density seed numsplits outputdirectory
16 | ````
17 | 
18 | In the case of Usage 1, if you don't specify pr, pc it will generate a 1D split and 2D otherwise.
19 | The usage 2, generates splits for 1D and 2D random sparse matrix. The usage 2 may not be needed
20 | for this library as it can generate synthetic matrix on the fly in memory. 
21 | 
22 | 4. The file processstackexchange.txt, gives the shell command listing for converting
23 | the .xml file into a .txt file that contains one question every line. This can then be
24 | consumed into mangodb or use some python scripting tool to build the sparse bag of words 
25 | matrix. The sparse bag of words matrix can be uniformly split using the splitfiles utility
26 | explained above. 
27 | 
28 | 5. shufflesparsemm.py shuffles the sparse matrix in coordinate format for load balancing.
29 | It permutes both the rows and the columns of the matrix. It can be run as 
30 | 
31 | ````
32 | python shufflesparsemm.py -i inputfile -o outputfile
33 | ````
34 | 
35 | Once completed running it generates three files. Shuffled matrix file and the
36 | outputfile_rowperm as the row permutation indexes and the outputfile_colperm as
37 | col permutation indexes


--------------------------------------------------------------------------------
/ntf/ntf.cpp:
--------------------------------------------------------------------------------
 1 | /* Copyright Ramakrishnan Kannan 2017 */
 2 | 
 3 | #include <iostream>
 4 | #include "common/utils.h"
 5 | #include "common/ncpfactors.hpp"
 6 | #include "common/ntf_utils.hpp"
 7 | #include "common/parsecommandline.hpp"
 8 | #include "common/tensor.hpp"
 9 | #include "ntf/ntfanlsbpp.hpp"
10 | #include "ntf/ntfaoadmm.hpp"
11 | #include "ntf/ntfhals.hpp"
12 | #include "ntf/ntfmu.hpp"
13 | #include "ntf/ntfnes.hpp"
14 | 
15 | // ntf -d "2 3 4 5" -k 5 -t 20
16 | 
17 | namespace planc {
18 | 
19 | class NTFDriver {
20 |  public:
21 |   template <class NTFTYPE>
22 |   void callNTF(planc::ParseCommandLine pc) {
23 |     int test_modes = pc.num_modes();
24 |     UVEC dimensions(test_modes);
25 |     Tensor my_tensor(pc.dimensions());
26 |     std::string rand_prefix("rand_");
27 |     std::string filename = pc.input_file_name();
28 |     std::cout << "Input filename = " << filename << std::endl;
29 |     if (!filename.empty() &&
30 |         filename.compare(0, rand_prefix.size(), rand_prefix) != 0) {
31 |       my_tensor.read(pc.input_file_name());
32 |       my_tensor.print();
33 |     }
34 |     NTFTYPE ntfsolver(my_tensor, pc.lowrankk(), pc.lucalgo());
35 |     ntfsolver.num_it(pc.iterations());
36 |     ntfsolver.compute_error(pc.compute_error());
37 |     if (pc.dim_tree()) {
38 |       ntfsolver.dim_tree(true);
39 |     }
40 |     ntfsolver.computeNTF();
41 |     // ntfsolver.ncp_factors().print();
42 |   }
43 |   NTFDriver() {}
44 | };  // class NTF Driver
45 | 
46 | }  // namespace planc
47 | 
48 | int main(int argc, char* argv[]) {
49 |   planc::ParseCommandLine pc(argc, argv);
50 |   pc.parseplancopts();
51 |   planc::NTFDriver ntfd;
52 |   switch (pc.lucalgo()) {
53 |     case MU:
54 |       ntfd.callNTF<planc::NTFMU>(pc);
55 |       break;
56 |     case HALS:
57 |       ntfd.callNTF<planc::NTFHALS>(pc);
58 |       break;
59 |     case ANLSBPP:
60 |       ntfd.callNTF<planc::NTFANLSBPP>(pc);
61 |       break;
62 |     case AOADMM:
63 |       ntfd.callNTF<planc::NTFAOADMM>(pc);
64 |       break;
65 |     case NESTEROV:
66 |       ntfd.callNTF<planc::NTFNES>(pc);
67 |       break;
68 |     default:
69 |       ERR << "Wrong algorithm choice. Quitting.." << pc.lucalgo() << std::endl;
70 |   }
71 | }
72 | 


--------------------------------------------------------------------------------
/distnmf/distr2.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef DISTNMF_DISTR2_HPP_
 2 | #define DISTNMF_DISTR2_HPP_
 3 | #include "distnmf/aunmf.hpp"
 4 | 
 5 | /**
 6 |  * Distrubted Rank-2 AUNMF Factorization
 7 |  */
 8 | 
 9 | namespace planc {
10 |   
11 |   template <class INPUTMATTYPE>
12 |   class DistR2 : public DistAUNMF<INPUTMATTYPE> {
13 |     private:
14 |       MAT Huv;
15 |       MAT Wuv;
16 |     protected:
17 |       void updateW() {
18 |         //HHt AHt
19 |         MPITIC;
20 |         update(this->HtH, this->AHtij, this->Wuv, this->Wt);
21 |         this->W = this->Wt.t();
22 |         double temp = MPITOC;
23 |         this->reportTime(temp,"updateW::");
24 |       }
25 |       void updateH() {
26 |         //WtW, (WtA)t
27 |         MPITIC;
28 |         update(this->WtW, this->WtAij, this->Huv, this->Ht);
29 |         this->H = this->Ht.t();
30 |         double temp = MPITOC;
31 |         this->reportTime(temp,"updateH::");
32 |       }
33 | 
34 |     private:
35 |       void update(MAT& left, const MAT& right, MAT& uv, MAT& G) {
36 |         MPITIC;
37 |         G = solve(left, right, arma::solve_opts::fast + arma::solve_opts::allow_ugly);
38 |         double temp = MPITOC;
39 |         this->reportTime(temp,"G::");
40 | 
41 |         MPITIC;
42 |         uv.row(0) = right.row(0) / left(0,0);
43 |         uv.row(1) = right.row(1) / left(1,1);
44 | 
45 |         auto b0 = sqrt(left(0,0));
46 |         auto b1 = sqrt(left(1,1));
47 | 
48 |         UVEC negs = find(any(G<0));
49 | 
50 |         uv.each_col( [&,b0,b1](VEC& b) {
51 |             if (b0*b(0) >= b1*b(1)) {
52 |               b(1) = 0;
53 |             } else {
54 |               b(0) = 0;
55 |             }
56 |           });
57 |         
58 |         G.cols(negs) = uv.cols(negs);
59 |         temp = MPITOC;
60 |         this->reportTime(temp,"UV::");
61 |       }
62 | 
63 | 
64 |     public:
65 |       DistR2(const INPUTMATTYPE& input, const MAT& leftlowrankfactor, const MAT& rightlowrankfactor, const MPICommunicator& communicator, const int numkblks) : DistAUNMF<INPUTMATTYPE>(input, leftlowrankfactor, rightlowrankfactor, communicator, numkblks) {
66 |         Wuv.zeros(2,this->W.n_rows);
67 |         Huv.zeros(2,this->H.n_rows);
68 |         
69 |       }
70 |   };
71 | }
72 | #endif
73 | 


--------------------------------------------------------------------------------
/license.dat:
--------------------------------------------------------------------------------
 1 | Copyright 2016 , UT-Battelle, LLC
 2 | All rights reserved
 3 | OPEN SOURCE LICENSE (Permissive)
 4 | 
 5 | Subject to the conditions of this License, UT-Battelle, LLC (the “Licensor”) hereby grants, free of charge, to any person (the “Licensee”) obtaining a copy of this software and associated documentation files (the "Software"), a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to use, copy, modify, merge, publish, distribute, and/or sublicense copies of the Software.
 6 | 
 7 | 1. Redistributions of Software must retain the above open source license grant, copyright and license notices, this list of conditions, and the disclaimer listed below.  Changes or modifications to, or derivative works of the Software must be noted with comments and the contributor and organization’s name.
 8 | 
 9 | 2. Neither the names of Licensor, the Department of Energy, or their employees may be used to endorse or promote products derived from this Software without their specific prior written permission.
10 | 
11 | 3. If the Software is protected by a proprietary trademark owned by Licensor or the Department of Energy, then derivative works of the Software may not be distributed using the trademark without the prior written approval of the trademark owner. 
12 | 	
13 | ****************************************************************************************************************
14 | DISCLAIMER
15 | 
16 | UT-Battelle, LLC AND THE GOVERNMENT MAKE NO REPRESENTATIONS AND DISCLAIM ALL WARRANTIES, BOTH EXPRESSED AND IMPLIED.  THERE ARE NO EXPRESS OR IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, OR THAT THE USE OF THE SOFTWARE WILL NOT INFRINGE ANY PATENT, COPYRIGHT, TRADEMARK, OR OTHER PROPRIETARY RIGHTS, OR THAT THE SOFTWARE WILL ACCOMPLISH THE INTENDED RESULTS OR THAT THE SOFTWARE OR ITS USE WILL NOT RESULT IN INJURY OR DAMAGE.  The user assumes responsibility for all liabilities, penalties, fines, claims, causes of action, and costs and expenses, caused by, resulting from or arising out of, in whole or in part the use, storage or disposal of the SOFTWARE.
17 | 
18 | ****************************************************************************************************************


--------------------------------------------------------------------------------
/ntf/ntfanlsbpp.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright Ramakrishnan Kannan 2018 */
 2 | 
 3 | #ifndef NTF_NTFANLSBPP_HPP_
 4 | #define NTF_NTFANLSBPP_HPP_
 5 | 
 6 | #include "nnls/bppnnls.hpp"
 7 | #include "ntf/auntf.hpp"
 8 | 
 9 | namespace planc {
10 | 
11 | #define ONE_THREAD_MATRIX_SIZE 2000
12 | 
13 | class NTFANLSBPP : public AUNTF {
14 |  protected:
15 |   MAT update(const int mode) {
16 |     MAT othermat(this->m_ncp_factors.factor(mode).t());
17 |     UINT nrhs = this->ncp_mttkrp_t[mode].n_cols;
18 |     UINT numChunks = nrhs / ONE_THREAD_MATRIX_SIZE;
19 |     if (numChunks * ONE_THREAD_MATRIX_SIZE < nrhs) numChunks++;
20 | 
21 | // #pragma omp parallel for schedule(dynamic)
22 |     for (UINT i = 0; i < numChunks; i++) {
23 |       UINT spanStart = i * ONE_THREAD_MATRIX_SIZE;
24 |       UINT spanEnd = (i + 1) * ONE_THREAD_MATRIX_SIZE - 1;
25 |       if (spanEnd > nrhs - 1) {
26 |         spanEnd = nrhs - 1;
27 |       }
28 | 
29 |       BPPNNLS<MAT, VEC> subProblem(this->gram_without_one,
30 |                         (MAT)this->ncp_mttkrp_t[mode].cols(spanStart, spanEnd),
31 |                         true);
32 | #ifdef _VERBOSE
33 |       // #pragma omp critical
34 |       {
35 |         INFO << "Scheduling " << worh << " start=" << spanStart
36 |              << ", end=" << spanEnd
37 |              // << ", tid=" << omp_get_thread_num()
38 |              << std::endl
39 |              << "LHS ::" << std::endl
40 |              << this->gram_without_one << std::endl
41 |              << "RHS ::" << std::endl
42 |              << this->ncp_mttkrp_t[mode].cols(spanStart, spanEnd) << std::endl;
43 |       }
44 | #endif
45 | 
46 |       subProblem.solveNNLS();
47 | 
48 | #ifdef _VERBOSE
49 |       INFO << "completed " << worh << " start=" << spanStart
50 |            << ", end=" << spanEnd
51 |            // << ", tid=" << omp_get_thread_num() << " cpu=" << sched_getcpu()
52 |            << " time taken=" << t2 << std::endl;
53 | #endif
54 |       othermat.cols(spanStart, spanEnd) = subProblem.getSolutionMatrix();
55 |     }
56 |     return othermat;
57 |   }
58 | 
59 |  public:
60 |   NTFANLSBPP(const Tensor &i_tensor, const int i_k, algotype i_algo)
61 |       : AUNTF(i_tensor, i_k, i_algo) {}
62 | };  // class NTFANLSBPP
63 | 
64 | }  // namespace planc
65 | 
66 | #endif  // NTF_NTFANLSBPP_HPP_
67 | 


--------------------------------------------------------------------------------
/conf/nvblas_cuda91.conf:
--------------------------------------------------------------------------------
 1 | # This is the configuration file to use NVBLAS Library
 2 | # Setup the environment variable NVBLAS_CONFIG_FILE to specify your own config file.
 3 | # By default, if NVBLAS_CONFIG_FILE is not defined, 
 4 | # NVBLAS Library will try to open the file "nvblas.conf" in its current directory
 5 | # Example : NVBLAS_CONFIG_FILE  /home/cuda_user/my_nvblas.conf
 6 | # The config file should have restricted write permissions accesses
 7 | 
 8 | # Specify which output log file (default is stderr)
 9 | NVBLAS_LOGFILE  nvblas.log
10 | 
11 | # Enable trace log of every intercepted BLAS calls
12 | NVBLAS_TRACE_LOG_ENABLED
13 | 
14 | #Put here the CPU BLAS fallback Library of your choice
15 | #It is strongly advised to use full path to describe the location of the CPU Library
16 | NVBLAS_CPU_BLAS_LIB  /usr/lib/libopenblas.so
17 | #NVBLAS_CPU_BLAS_LIB  <mkl_path_installtion>/libmkl_rt.so
18 | 
19 | # List of GPU devices Id to participate to the computation 
20 | # Use ALL if you want all your GPUs to contribute
21 | # Use ALL0, if you want all your GPUs of the same type as device 0 to contribute
22 | # However, NVBLAS consider that all GPU have the same performance and PCI bandwidth
23 | # By default if no GPU are listed, only device 0 will be used
24 | 
25 | #NVBLAS_GPU_LIST 0 2 4
26 | #NVBLAS_GPU_LIST ALL
27 | NVBLAS_GPU_LIST 0
28 | 
29 | # Tile Dimension
30 | NVBLAS_TILE_DIM 2048
31 | 
32 | # Autopin Memory
33 | NVBLAS_AUTOPIN_MEM_ENABLED
34 | 
35 | #List of BLAS routines that are prevented from running on GPU (use for debugging purpose
36 | # The current list of BLAS routines supported by NVBLAS are
37 | # GEMM, SYRK, HERK, TRSM, TRMM, SYMM, HEMM, SYR2K, HER2K
38 | 
39 | #NVBLAS_GPU_DISABLED_SGEMM 
40 | #NVBLAS_GPU_DISABLED_DGEMM 
41 | #NVBLAS_GPU_DISABLED_CGEMM 
42 | #NVBLAS_GPU_DISABLED_ZGEMM 
43 | 
44 | # Computation can be optionally hybridized between CPU and GPU
45 | # By default, GPU-supported BLAS routines are ran fully on GPU
46 | # The option NVBLAS_CPU_RATIO_<BLAS_ROUTINE> give the ratio [0,1] 
47 | # of the amount of computation that should be done on CPU
48 | # CAUTION : this option should be used wisely because it can actually
49 | # significantly reduced the overall performance if too much work is given to CPU
50 | 
51 | #NVBLAS_CPU_RATIO_CGEMM 0.07
52 | NVBLAS_CPU_RATIO_DGEMM 0.0
53 | 


--------------------------------------------------------------------------------
/utilities/partitioner/configs/bench_configs.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "run_nmf_cit": [
 3 |             {
 4 |                 "feature_mat_path" : ".../feats.mtx",
 5 |                 "conn_mat_path" : ".../conns.mtx",
 6 |                 "format" : "mm",
 7 |                 "procs" : [4,9,16],
 8 |                 "pr" : [2,3,4],
 9 |                 "pc" : [2,3,4],
10 |                 "output_path" : ".../sanity_check_cit_hepth",
11 |                 "alpha" : [-1, 0, 10, 20],
12 |                 "beta" : [-1, 0, 1, 2],
13 |                 "m" : 1152,
14 |                 "n" : 4542601,
15 |                 "k" : [10, 5, 12, 14],
16 |                 "algorithm" : [2, 9],
17 |                 "iterations" : [100, 50],
18 |                 "planc_path": ".../build_dist/sparse_distnmf",
19 |                 "mpirun_path" : ".../mpirun",
20 |                 "debug" : "",
21 |                 "error" : "1",
22 |                 "just_parse": false,
23 |                 "partition" : true,
24 |                 "metadata_path": ".../metadata.mat",
25 |                 "matlab_output_path": ".../output/",
26 |                 "partitioner_output_path": ".../output/partitioned/"
27 |             }
28 |         ],"run_nmf_oag": [
29 |             {
30 |                 "feature_mat_path" : ".../feats.mtx",
31 |                 "conn_mat_path" : ".../conns.mtx",
32 |                 "format" : "mm",
33 |                 "procs" : [4,9,16],
34 |                 "pr" : [2,3,4],
35 |                 "pc" : [2,3,4],
36 |                 "output_path" : ".../sanity_check_cit_hepth",
37 |                 "alpha" : [-1, 0, 10, 20],
38 |                 "beta" : [-1, 0, 1, 2],
39 |                 "m" : 1152,
40 |                 "n" : 4542601,
41 |                 "k" : [10, 5, 12, 14],
42 |                 "algorithm" : [2, 9],
43 |                 "iterations" : [100, 50],
44 |                 "planc_path": ".../build_dist/sparse_distnmf",
45 |                 "mpirun_path" : ".../mpirun",
46 |                 "debug" : "",
47 |                 "error" : "1",
48 |                 "just_parse": false,
49 |                 "partition" : true,
50 |                 "metadata_path": ".../metadata.mat",
51 |                 "matlab_output_path": ".../output/",
52 |                 "partitioner_output_path": ".../output/partitioned/"
53 |             }
54 |         ]
55 | }


--------------------------------------------------------------------------------
/conf/nvblas_cuda75.conf:
--------------------------------------------------------------------------------
 1 | # This is the configuration file to use NVBLAS Library
 2 | # Setup the environment variable NVBLAS_CONFIG_FILE to specify your own config file.
 3 | # By default, if NVBLAS_CONFIG_FILE is not defined, 
 4 | # NVBLAS Library will try to open the file "nvblas.conf" in its current directory
 5 | # Example : NVBLAS_CONFIG_FILE  /home/cuda_user/my_nvblas.conf
 6 | # The config file should have restricted write permissions accesses
 7 | 
 8 | # Specify which output log file (default is stderr)
 9 | NVBLAS_LOGFILE  nvblas.log
10 | 
11 | # Enable trace log of every intercepted BLAS calls
12 | # NVBLAS_TRACE_LOG_ENABLED
13 | 
14 | #Put here the CPU BLAS fallback Library of your choice
15 | #It is strongly advised to use full path to describe the location of the CPU Library
16 | NVBLAS_CPU_BLAS_LIB /opt/cray/libsci/16.11.1/GNU/5.1/x86_64/lib/libsci_gnu.so 
17 | #NVBLAS_CPU_BLAS_LIB  <mkl_path_installtion>/libmkl_rt.so
18 | 
19 | # List of GPU devices Id to participate to the computation 
20 | # Use ALL if you want all your GPUs to contribute
21 | # Use ALL0, if you want all your GPUs of the same type as device 0 to contribute
22 | # However, NVBLAS consider that all GPU have the same performance and PCI bandwidth
23 | # By default if no GPU are listed, only device 0 will be used
24 | 
25 | NVBLAS_GPU_LIST 0
26 | #NVBLAS_GPU_LIST ALL
27 | #NVBLAS_GPU_LIST ALL0
28 | 
29 | # Tile Dimension
30 | # NVBLAS_TILE_DIM 2048
31 | 
32 | # Autopin Memory
33 | NVBLAS_AUTOPIN_MEM_ENABLED
34 | 
35 | #List of BLAS routines that are prevented from running on GPU (use for debugging purpose
36 | # The current list of BLAS routines supported by NVBLAS are
37 | # GEMM, SYRK, HERK, TRSM, TRMM, SYMM, HEMM, SYR2K, HER2K
38 | 
39 | #NVBLAS_GPU_DISABLED_SYRK 
40 | #NVBLAS_GPU_DISABLED_SGEMM 
41 | #NVBLAS_GPU_DISABLED_DGEMM 
42 | #NVBLAS_GPU_DISABLED_CGEMM 
43 | #NVBLAS_GPU_DISABLED_ZGEMM 
44 | 
45 | # Computation can be optionally hybridized between CPU and GPU
46 | # By default, GPU-supported BLAS routines are ran fully on GPU
47 | # The option NVBLAS_CPU_RATIO_<BLAS_ROUTINE> give the ratio [0,1] 
48 | # of the amount of computation that should be done on CPU
49 | # CAUTION : this option should be used wisely because it can actually
50 | # significantly reduced the overall performance if too much work is given to CPU
51 | 
52 | #NVBLAS_CPU_RATIO_CGEMM 0.07
53 | NVBLAS_CPU_RATIO_DGEMM 0.0
54 | 


--------------------------------------------------------------------------------
/common/utils.h:
--------------------------------------------------------------------------------
 1 | /* Copyright 2016 Ramakrishnan Kannan */
 2 | // utility functions
 3 | #ifndef COMMON_UTILS_H_
 4 | #define COMMON_UTILS_H_
 5 | 
 6 | // #ifndef _VERBOSE
 7 | // #define _VERBOSE 1
 8 | // #endif
 9 | 
10 | enum algotype { MU, HALS, ANLSBPP, NAIVEANLSBPP, AOADMM, 
11 |         NESTEROV, CPALS, GNSYM, R2, PGD, PGNCG };
12 | 
13 | enum normtype { NONE, L2NORM, MAXNORM };
14 | 
15 | enum helptype { NMF, DISTNMF, NTF, DISTNTF, JOINTNMF, DISTJOINTNMF, HIERNMF };
16 | 
17 | // #if !defined(ARMA_64BIT_WORD)
18 | // #define ARMA_64BIT_WORD
19 | #define ARMA_DONT_USE_WRAPPER
20 | #define ARMA_USE_BLAS
21 | #define ARMA_USE_LAPACK
22 | // #endif
23 | #include <armadillo>
24 | #include <cmath>
25 | #include <iostream>
26 | #include <vector>
27 | 
28 | // using namespace std;
29 | 
30 | #ifndef ERR
31 | #define ERR std::cerr
32 | #endif
33 | 
34 | #ifndef WARN
35 | #define WARN std::cerr
36 | #endif
37 | 
38 | #ifndef INFO
39 | #define INFO std::cout
40 | #endif
41 | 
42 | #ifndef OUTPUT
43 | #define OUTPUT std::cout
44 | #endif
45 | 
46 | #define EPSILON_1EMINUS16 0.00000000000000001
47 | #define EPSILON_1EMINUS8 0.00000001
48 | #define EPSILON 0.000001
49 | #define EPSILON_1EMINUS12 1e-12
50 | #define NUMBEROF_DECIMAL_PLACES 12
51 | #define RAND_SEED 100
52 | #define RAND_SEED_SPARSE 100
53 | #define WTRUE_SEED 1196089
54 | #define HTRUE_SEED 1230587
55 | 
56 | // defines for namespace confusion
57 | #define FMAT arma::fmat
58 | #define MAT arma::mat
59 | #define UMAT arma::umat
60 | #define FROWVEC arma::frowvec
61 | #define ROWVEC arma::rowvec
62 | #define UROWVEC arma::urowvec
63 | #define FVEC arma::fvec
64 | #define SP_FMAT arma::sp_fmat
65 | #define SP_MAT arma::sp_mat
66 | #define UVEC arma::uvec
67 | #define IVEC arma::ivec
68 | #define UWORD arma::uword
69 | #define VEC arma::vec
70 | 
71 | #define PRINTMATINFO(A) "::" #A "::" << (A).n_rows << "x" << (A).n_cols
72 | 
73 | #define PRINTMAT(A) PRINTMATINFO((A)) << std::endl << (A)
74 | 
75 | typedef std::vector<int> STDVEC;
76 | typedef unsigned int UINT;
77 | typedef unsigned int uint;
78 | typedef unsigned long ULONG;
79 | 
80 | void absmat(const FMAT *X);
81 | 
82 | inline void tic();
83 | inline double toc();
84 | 
85 | int random_sieve(const int);
86 | 
87 | template <typename FVT>
88 | inline void fillVector(const FVT value, std::vector<FVT> *a) {
89 |   for (unsigned int ii = 0; ii < a->size(); ii++) {
90 |     (*a)[ii] = value;
91 |   }
92 | }
93 | 
94 | #endif  // COMMON_UTILS_H_
95 | 


--------------------------------------------------------------------------------
/common/distutils.h:
--------------------------------------------------------------------------------
 1 | /* Copyright 2016 Ramakrishnan Kannan */
 2 | #ifndef COMMON_DISTUTILS_H_
 3 | #define COMMON_DISTUTILS_H_
 4 | 
 5 | #define APPEND_TIME 1
 6 | // #define MPI_VERBOSE       1
 7 | // #define WRITE_RAND_INPUT  1
 8 | // #define INIT_TRUE_LR      1
 9 | 
10 | // enum distalgotype {MU2D, HALS2D, ANLSBPP2D, NAIVEANLSBPP, AOADMM2D};
11 | 
12 | // ONED_DOUBLE for naive ANLS-BPP
13 | // TWOD for HPC-NMF
14 | enum iodistributions { ONED_ROW, ONED_COL, ONED_DOUBLE, TWOD };
15 | 
16 | #define ISROOT this->m_mpicomm.rank() == 0
17 | #define MPI_SIZE this->m_mpicomm.size()
18 | #define MPI_RANK this->m_mpicomm.rank()
19 | #define MPI_ROW_RANK this->m_mpicomm.row_rank()
20 | #define MPI_COL_RANK this->m_mpicomm.col_rank()
21 | #define MPI_FIBER_RANK(i) this->m_mpicomm.fiber_rank(i)
22 | #define MPI_SLICE_RANK(i) this->m_mpicomm.slice_rank(i)
23 | #define NUMROWPROCS this->m_mpicomm.pr()
24 | #define NUMCOLPROCS this->m_mpicomm.pc()
25 | 
26 | // Macros when there are multiple communicators
27 | #define ISROOT_C(comm) comm.rank() == 0
28 | #define MPI_SIZE_C(comm) comm.size()
29 | #define MPI_RANK_C(comm) comm.rank()
30 | #define MPI_ROW_RANK_C(comm) comm.row_rank()
31 | #define MPI_COL_RANK_C(comm) comm.col_rank()
32 | #define NUMROWPROCS_C(comm) comm.pr()
33 | #define NUMCOLPROCS_C(comm) comm.pc()
34 | 
35 | // #define MPITIC tic()
36 | // #define MPITOC toc()
37 | #define MPITIC mpitic()
38 | #define MPITOC mpitoc()
39 | // #define MPITIC mpitic(MPI_RANK)
40 | // #define MPITOC mpitoc(MPI_RANK)
41 | 
42 | // #define PRINTROOT(MSG)
43 | #define PRINTROOT(MSG)                                                         \
44 |   if (ISROOT)                                                                  \
45 |     INFO << "::" << __PRETTY_FUNCTION__ << "::" << __LINE__                    \
46 |          << "::" << std::endl                                                  \
47 |          << MSG << std::endl;
48 | #define DISTPRINTINFO(MSG)                                                     \
49 |   INFO << MPI_RANK << "::" << __PRETTY_FUNCTION__ << "::" << __LINE__          \
50 |        << "::" << std::endl                                                    \
51 |        << MSG << std::endl;
52 | #define PRINTTICTOCTOP                                                         \
53 |   if (ISROOT)                                                                  \
54 |     INFO << "tictoc::" << tictoc_stack.top() << std::endl;
55 | 
56 | #endif // COMMON_DISTUTILS_H_
57 | 


--------------------------------------------------------------------------------
/utilities/shufflesparsemm.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import scipy.sparse as sp
 3 | import sys
 4 | import getopt
 5 | 
 6 | ###############################################################################
 7 | # This file takes a sparse matrix as input file and shuffles it
 8 | # python shufflesparsemm.py -i inputfile -o outputfile
 9 | # There will be three outputfiles -- shuffled matrix, row and col permutation
10 | ###############################################################################
11 | 
12 | def save_sparse_matrix(filename,x):
13 |     print 'finding the sparse entries'
14 |     [rowidx,colidx,val]=sp.find(x)
15 |     y = np.column_stack((rowidx,colidx,val))
16 |     print 'saving shuffled matrix '
17 |     np.savetxt(filename,y,fmt='%u',delimiter=' ')
18 | 
19 | def load_sparse_matrix(filename):
20 |     y=np.loadtxt(filename)
21 |     num_rows=max(y[:,0])+1
22 |     num_cols=max(y[:,1])+1
23 |     print 'loading input matrix'
24 |     z=sp.csr_matrix((y[:,2], (y[:,0],y[:,1])),shape=(num_rows,num_cols), dtype=np.int32)
25 |     return z
26 | 
27 | def randomize_matrix(input_file_name,output_file_name):
28 |     z=load_sparse_matrix(input_file_name)
29 |     print 'loaded input matrix'
30 |     shape=z.shape
31 |     print 'shuffling row idxs'
32 |     rowperm=np.arange(0,shape[0],dtype=np.int32)
33 |     np.random.shuffle(rowperm)
34 |     print 'shuffling col idxs'
35 |     colperm=np.arange(0,shape[1],dtype=np.int32)
36 |     np.random.shuffle(colperm)
37 |     print 'starting input matrix shuffle'
38 |     z_rnd=z[rowperm,:]
39 |     z_rnd=z_rnd[:,colperm]
40 |     print 'shuffled input matrix'
41 |     save_sparse_matrix(output_file_name, sp.csr_matrix.tocoo(z_rnd))
42 |     np.savetxt(output_file_name+ '_rowperm', rowperm,fmt='%u')
43 |     np.savetxt(output_file_name+'_colperm', colperm,fmt='%u')
44 | 
45 | def main(argv):
46 |    inputfile=''
47 |    outputfile=''
48 |    try:
49 |       opts, args = getopt.getopt(argv,"hi:o:",["ifile=","ofile="])
50 |    except getopt.GetoptError:
51 |       print 'shufflesparsemm -i <inputfile> -o <outputfile>'
52 |       sys.exit(2)
53 |    for opt, arg in opts:
54 |       if opt == '-h':
55 |           print 'shufflesparsemm -i <inputfile> -o <outputfile>'
56 |           sys.exit()
57 |       elif opt in ("-i", "--ifile"):
58 |           inputfile = arg
59 |       elif opt in ("-o", "--ofile"):
60 |           outputfile = arg
61 |    randomize_matrix(inputfile,outputfile)
62 | 
63 | if __name__ == "__main__":
64 |    main(sys.argv[1:])


--------------------------------------------------------------------------------
/utilities/partitioner/planc_partitioner.py:
--------------------------------------------------------------------------------
 1 | import math
 2 | from itertools import accumulate
 3 | import re
 4 | import os
 5 | 
 6 | class planc_partitioner:
 7 |     def __init__(self):
 8 |         pass
 9 | 
10 |     def partition(self,feature_mat_path, output_path, A, nrows, ncols, pr, pc):
11 |         pass
12 | 
13 |         print('hello from partition function')
14 |         
15 |         t = A.tocsr()
16 | 
17 |         n = self.itersplit(nrows,ncols,pr,pc)
18 |         print(n)
19 | 
20 |         op = os.path.join(output_path, os.path.basename(feature_mat_path))
21 | 
22 |         for i in range(pr):
23 |             for j in range(pc):
24 |                 pass
25 |                 print('proc: (' + str(i) + ',' + str(j) + ')')
26 |                 print('row start indices: ' + str(n[0][i]) + '  row end indices: ' + str(n[0][i+1]))
27 |                 print('col start indices: ' + str(n[1][j]) + '  col end indices: ' + str(n[1][j+1]))
28 | 
29 |                 temp = t[n[0][i]:(n[0][i+1]), n[1][j]:(n[1][j+1])]
30 | 
31 |                 # save matrix i_j ----> assuming that csr form is correct format...
32 |                 # https://stackoverflow.com/questions/55690069/how-to-write-a-sparse-matrix-in-a-text-file-in-python
33 |                 temp.maxprint = temp.count_nonzero() 
34 |                 
35 |                 with open(op + str(i) + '_' + str(j), 'w') as f:
36 |                     mat = str(temp)
37 |                     mat = mat.replace(')','').replace('(','').replace(',','')
38 | 
39 |                     f.write(mat)
40 |                     f.close()
41 | 
42 |         return op
43 | 
44 | 
45 |         
46 | 
47 | 
48 |     def itersplit(self,nrows,ncols,pr,pc):
49 |         pass
50 | 
51 |         n = [[0] * pr, [0] * pc] 
52 |         print(n)
53 | 
54 |         row_div = math.floor(nrows / pr)
55 |         col_div = math.floor(ncols / pc)
56 | 
57 |         row_mod = nrows % pr
58 |         col_mod = ncols % pc
59 | 
60 |         for row in range(len(n[0])):
61 |             pass
62 |             # print('(' + str(row) + ',' + str(col) + ')')
63 |             if row < row_mod:
64 |                 n[0][row] = row_div + 1
65 |             else:
66 |                 n[0][row] = row_div
67 | 
68 |         for col in range(len(n[1])):
69 |             pass
70 |             if col < col_mod:
71 |                 n[1][col] = col_div + 1
72 |             else:
73 |                 n[1][col] = col_div
74 | 
75 |         #prefix sum 
76 |         n[0] = list(accumulate(n[0]))
77 |         n[1] = list(accumulate(n[1]))
78 | 
79 |         n[0].insert(0,0)
80 |         n[1].insert(0,0)
81 | 
82 |         return n


--------------------------------------------------------------------------------
/distnmf/distals.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright 2016 Ramakrishnan Kannan */
 2 | 
 3 | #ifndef DISTNMF_DISTALS_HPP_
 4 | #define DISTNMF_DISTALS_HPP_
 5 | #include "distnmf/aunmf.hpp"
 6 | 
 7 | /**
 8 |  * Unconstrained least squares. Should match the SVD
 9 |  * objective error.  
10 |  */
11 | 
12 | namespace planc {
13 | 
14 | template <class INPUTMATTYPE>
15 | class DistALS : public DistAUNMF<INPUTMATTYPE> {
16 |  protected:
17 |   /**
18 |    * update W given HtH and AHt
19 |    * AHtij is of size \f$ k \times \frac{globalm}/{p} \f$.
20 |    * this->W is of size \f$ \frac{globalm}{p} \times k \f$
21 |    * this->HtH is of size kxk
22 |   */
23 |   void updateW() {
24 |     this->Wt = arma::solve(arma::trimatl(this->HtH), this->AHtij);
25 |     this->W = this->Wt.t();
26 |     DISTPRINTINFO("ALS::updateW::HtH::" << PRINTMATINFO(this->HtH)
27 |                                         << "::AHtij::"
28 |                                         << PRINTMATINFO(this->AHtij)
29 |                                         << "::W::" << PRINTMATINFO(this->W));
30 |     DISTPRINTINFO("ALS::updateW::HtH::" << norm(this->HtH, "fro") << "::AHtij::"
31 |                                         << norm(this->AHtij, "fro")
32 |                                         << "::W::" << norm(this->W, "fro"));
33 |   }
34 |   /**
35 |    * updateH given WtAij and WtW
36 |    *  WtAij is of size \f$k \times \frac{globaln}{p} \f$
37 |    * this->H is of size \f$ \frac{globaln}{p} \times k\f$
38 |    * this->WtW is of size kxk
39 |    */
40 |   void updateH() {
41 |     this->Ht = arma::solve(arma::trimatl(this->WtW), this->WtAij);
42 |     this->H = this->Ht.t();
43 |     DISTPRINTINFO("ALS::updateH::WtW::" << PRINTMATINFO(this->WtW)
44 |                                         << "::WtAij::"
45 |                                         << PRINTMATINFO(this->WtAij)
46 |                                         << "::H::" << PRINTMATINFO(this->H));
47 |     DISTPRINTINFO("ALS::updateH::WtW::" << norm(this->WtW, "fro") << "::WtAij::"
48 |                                         << norm(this->WtAij, "fro")
49 |                                         << "::H::" << norm(this->H, "fro"));
50 |   }
51 | 
52 |  public:
53 |   DistALS(const INPUTMATTYPE& input, const MAT& leftlowrankfactor,
54 |           const MAT& rightlowrankfactor, const MPICommunicator& communicator,
55 |           const int numkblks)
56 |       : DistAUNMF<INPUTMATTYPE>(input, leftlowrankfactor, rightlowrankfactor,
57 |                                 communicator, numkblks) {
58 |     PRINTROOT("DistALS() constructor successful");
59 |   }
60 | };
61 | 
62 | }  // namespace planc
63 | 
64 | #endif  // DISTNMF_DISTALS_HPP_
65 | 


--------------------------------------------------------------------------------
/utilities/partitioner/check_symm.py:
--------------------------------------------------------------------------------
 1 | # NOTE: this checks whether the output from rand_symm functions is actually symmetric...
 2 | import numpy as np
 3 | import sys
 4 | from planc_partitioner import planc_partitioner
 5 | from pandas import *
 6 | # import pyarma
 7 | # from pyarma import *
 8 | 
 9 | # USAGE: python3 check_symm.py path_to_rnd_output/prefix m n k pr pc print? dense?
10 | # EXAMPLE: python3 check_symm.py ~/Desktop/Projects/PLANC/nmflibrary/build/build_joint/Srnd 23 11 2
11 | # 3 2 true true
12 | try:
13 |     planc_output_path = sys.argv[1]
14 |     m = int(sys.argv[2])
15 |     n = int(sys.argv[3])
16 |     k = int(sys.argv[4])
17 |     pr = int(sys.argv[5])
18 |     pc = int(sys.argv[6])
19 |     print_opt = sys.argv[7]
20 |     dense = sys.argv[8]
21 | except:
22 |     print('USAGE: python3 check_symm.py path_to_rnd_output/prefix m n k pr pc print? dense?')
23 |     exit()
24 | 
25 | print("dense = {}, print = {}".format(dense, print_opt))
26 | 
27 | A = np.zeros((n, n))
28 | test = planc_partitioner()
29 | 
30 | b = test.itersplit(n, n, pr, pc)
31 | print(b)
32 | 
33 | for i in range(pr):
34 |     pass
35 |     for j in range(pc):
36 |         pass
37 |     # NOTE: PLANC writes out random output in linear process order, not with the grid dimensions.
38 |     # Here we assume that the linear indexing is in row-major order...
39 |     # t1 = b[0][i] : (b[0][i+1])
40 |     # t2 = b[1][j] : (b[1][j+1])
41 |         # print(str(i) + ", " + str(j))
42 |         file_path = planc_output_path + "_" + str(pr * pc) + "_" + str(i*pc + j)
43 |         print(file_path)
44 |         # A[b[0][i] : (b[0][i+1]), b[1][j] : (b[1][j+1])]    
45 | 
46 |         #  NOTE rand output is written out to file via armadillo, not mpi...
47 |         # G = np.fromfile(file_path, 'float64')
48 | 
49 |         if dense == "true":
50 |             #G = mat()
51 |             #G.load(file_path)
52 |             G = np.fromfile(file_path, dtype=np.float64, sep=" ")
53 |             G.resize( b[0][i+1] - b[0][i], b[1][j+1] - b[1][j])
54 |             #print(G)
55 |             A[b[0][i] : (b[0][i+1]), b[1][j] : (b[1][j+1])] = G
56 |         else:
57 |             with open(file_path) as f:
58 |                 lines = f.readlines()
59 |             # print(lines)
60 |             for l in lines:
61 |                 t = l.split()
62 |                 A[b[0][i] + int(t[0])][b[1][j] + int(t[1])] = float(t[2])
63 | 
64 | 
65 | np.set_printoptions(precision=2)
66 | if print_opt == "true":
67 |     print(DataFrame(A))
68 | for i in range(n):
69 |     for j in range(n):
70 |         if A[i][j] != A[j][i]:
71 |             raise Exception("(A[" + str(i) + "][" + str(j) + "] = " + str(A[i][j]) + ")   !=   (A[" + str(j) + "][" + str(i) + "] = " + str(A[j][i]) + ")" )
72 | 
73 | print("matrix is symmetric")
74 | 


--------------------------------------------------------------------------------
/distntf/testcases.md:
--------------------------------------------------------------------------------
 1 | Sample test cases executed and verified for output. The output of each of the command is obtained by grepping for "relative_error"
 2 | 
 3 | * mpirun -np 1 ./distntf -a 2 -k 3 -d "8 8 8" -p "1 1 1" -i rand_lowrank -t 3 -e 1
 4 | =========================
 5 | Iter::0::relative_error::0.991104
 6 | Iter::1::relative_error::0.991008
 7 | Iter::2::relative_error::0.990957
 8 | Iter::3::relative_error::0.990952
 9 | Iter::4::relative_error::0.990952
10 | Iter::5::relative_error::0.990951
11 | Iter::6::relative_error::0.990952
12 | Iter::7::relative_error::0.990952
13 | Iter::8::relative_error::0.990952
14 | Iter::9::relative_error::0.990952
15 | Iter::10::relative_error::0.990952
16 | Iter::11::relative_error::0.990952
17 | Iter::12::relative_error::0.990952
18 | Iter::13::relative_error::0.990952
19 | Iter::14::relative_error::0.990952
20 | Iter::15::relative_error::0.990952
21 | Iter::16::relative_error::0.990952
22 | Iter::17::relative_error::0.990952
23 | Iter::18::relative_error::0.990952
24 | Iter::19::relative_error::0.990952
25 | Iter::20::relative_error::0.990952
26 | Iter::21::relative_error::0.990952
27 | Iter::22::relative_error::0.990952
28 | Iter::23::relative_error::0.990952
29 | Iter::24::relative_error::0.990952
30 | Iter::25::relative_error::0.990952
31 | Iter::26::relative_error::0.990952
32 | Iter::27::relative_error::0.990952
33 | Iter::28::relative_error::0.990952
34 | Iter::29::relative_error::0.990952
35 | =========================
36 | * mpirun -np 1 ./distntf -a 2 -k 3 -d "8 8 8" -p "1 1 1" -i rand_lowrank -t 30 -e 1 --dimtree=1
37 | =========================
38 | Iter::0::relative_error::0.991104
39 | Iter::1::relative_error::0.991008
40 | Iter::2::relative_error::0.990957
41 | Iter::3::relative_error::0.990952
42 | Iter::4::relative_error::0.990952
43 | Iter::5::relative_error::0.990951
44 | Iter::6::relative_error::0.990952
45 | Iter::7::relative_error::0.990952
46 | Iter::8::relative_error::0.990952
47 | Iter::9::relative_error::0.990952
48 | Iter::10::relative_error::0.990952
49 | Iter::11::relative_error::0.990952
50 | Iter::12::relative_error::0.990952
51 | Iter::13::relative_error::0.990952
52 | Iter::14::relative_error::0.990952
53 | Iter::15::relative_error::0.990952
54 | Iter::16::relative_error::0.990952
55 | Iter::17::relative_error::0.990952
56 | Iter::18::relative_error::0.990952
57 | Iter::19::relative_error::0.990952
58 | Iter::20::relative_error::0.990952
59 | Iter::21::relative_error::0.990952
60 | Iter::22::relative_error::0.990952
61 | Iter::23::relative_error::0.990952
62 | Iter::24::relative_error::0.990952
63 | Iter::25::relative_error::0.990952
64 | Iter::26::relative_error::0.990952
65 | Iter::27::relative_error::0.990952
66 | Iter::28::relative_error::0.990952
67 | Iter::29::relative_error::0.990952
68 | =========================
69 | * mpirun -np 8 ./distntf -a 2 -k 3 -d "64 64 64" -p "2 2 2" -i rand_uniform -t 30 -e 1 --dimtree=1
70 | 


--------------------------------------------------------------------------------
/jointnmf/README.md:
--------------------------------------------------------------------------------
 1 | # OpenMP Joint Nonnegative Matrix Factorization 
 2 | 
 3 | ## Install Instructions
 4 | 
 5 | 
 6 | This program depends on:
 7 | 
 8 | - [Armadillo](https://arma.sourceforge.net) library for linear algebra operations.
 9 | - [OpenBLAS](https://github.com/xianyi/OpenBLAS) for optimized kernels. If building with OpenBLAS and MKL is discoverable by `cmake`, use `-DCMAKE_IGNORE_MKL=1` while building. 
10 | 
11 | Once you have installed these libraries set the following environment variables.
12 | 
13 | ````
14 | export ARMADILLO_INCLUDE_DIR=/home/rnu/libraries/armadillo-6.600.5/include/
15 | export LIB=$LIB:/home/rnu/libraries/openblas/lib:
16 | export INCLUDE=$INCLUDE:/home/rnu/libraries/openblas/include:$ARMADILLO_INCLUDE_DIR:
17 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/rnu/libraries/openblas/lib/:
18 | export CPATH=CPATH:$INCLUDE:
19 | ````
20 | 
21 | * Create a build directory. 
22 | * Change to the build directory 
23 | * In case of MKL, `source` the ````$MKLROOT/bin/mkl_vars.sh intel64````
24 | * run `cmake` [PATH TO THE CMakeList.txt]
25 | * `make`
26 | 
27 | Refer to the build scripts found in the [build](build/README.md) directory for a sample script.
28 | 
29 | ### Input types
30 | JointNMF requires two input matrices, the features and connections matrices, to run on.
31 | PLANC is able to support any sparsity combination of the inputs to run on be default.
32 | However, specialized builds can be constructed for each type if needed via the following `cmake` flags.
33 | 1. `-DCMAKE_BUILD_SPSP=1` sets the build to expect sparse features and sparse connections matrices.
34 | 2. `-DCMAKE_BUILD_SPDEN=1` sets the build to expect sparse features and dense connections matrices.
35 | 3. `-DCMAKE_BUILD_DENSP=1` sets the build to expect dense features and sparse connections matrices.
36 | 4. `-DCMAKE_BUILD_DENDEN=1` sets the build to expect dense features and dense connections matrices.
37 | 
38 | ### Intel MKL vs OpenBLAS
39 | 
40 | - ````export LD_LIBRARY_PATH=MKL_LIB path````
41 | - `source` the ````$MKLROOT/bin/mkl_vars.sh intel64````
42 | 
43 | ## Runtime usage
44 | 
45 | Tell OpenBLAS how many threads you want to use. For example on a quad core system use the following.
46 | 
47 | ```
48 | export OPENBLAS_NUM_THREADS=4
49 | export MKL_NUM_THREADS=4
50 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:MKL_LIB
51 | ```
52 | 
53 | ## Command Line options
54 | The specialized command line options for the JointNMF binaries are given below.
55 | * `--mat_type`: An array parameter specifying the sparsity type of the input matrices.
56 | * `--alpha`: This parameter modifies the objective function to control the importance given to each of the fit terms (features and connections).
57 | * `--beta`: The symmetric regularization parameter in the ANLS algorithm.
58 | * `--gamma`: The momentum term for the PGD algorithm. 
59 | 
60 | ## Citation
61 | 
62 | Please refer to the [papers](papers.md) section for the appropriate reports to cite.
63 | 


--------------------------------------------------------------------------------
/distntf/distntfanlsbpp.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright Ramakrishnan Kannan 2018 */
 2 | 
 3 | #ifndef DISTNTF_DISTNTFANLSBPP_HPP_
 4 | #define DISTNTF_DISTNTFANLSBPP_HPP_
 5 | 
 6 | #include "distntf/distauntf.hpp"
 7 | #include "nnls/bppnnls.hpp"
 8 | 
 9 | namespace planc {
10 | 
11 | #define ONE_THREAD_MATRIX_SIZE 2000
12 | 
13 | class DistNTFANLSBPP : public DistAUNTF {
14 |  protected:
15 |   /**
16 |    * ANLS/BPP update function.
17 |    * Given the MTTKRP and the hadamard of all the grams, we 
18 |    * determine the factor matrix to be updated. 
19 |    * @param[in] Mode of the factor to be updated
20 |    * @returns The new updated factor
21 |    */
22 |   MAT update(const int mode) {
23 |     MAT othermat(this->m_local_ncp_factors_t.factor(mode));
24 |     if (m_nls_sizes[mode] > 0) {
25 |       UINT nrhs = this->ncp_local_mttkrp_t[mode].n_cols;
26 |       UINT numChunks = nrhs / ONE_THREAD_MATRIX_SIZE;
27 |       if (numChunks * ONE_THREAD_MATRIX_SIZE < nrhs) numChunks++;
28 |       // #pragma omp parallel for schedule(dynamic)
29 |       for (UINT i = 0; i < numChunks; i++) {
30 |         UINT spanStart = i * ONE_THREAD_MATRIX_SIZE;
31 |         UINT spanEnd = (i + 1) * ONE_THREAD_MATRIX_SIZE - 1;
32 |         if (spanEnd > nrhs - 1) {
33 |           spanEnd = nrhs - 1;
34 |         }
35 |         BPPNNLS<MAT, VEC> subProblem(this->global_gram,
36 |                   (MAT)this->ncp_local_mttkrp_t[mode].cols(spanStart, spanEnd),
37 |                   true);
38 | #ifdef _VERBOSE
39 |       // #pragma omp critical
40 |         {
41 |           INFO << "Scheduling " << worh << " start=" << spanStart
42 |              << ", end=" << spanEnd
43 |              // << ", tid=" << omp_get_thread_num()
44 |              << std::endl
45 |              << "LHS ::" << std::endl
46 |              << giventGiven << std::endl
47 |              << "RHS ::" << std::endl
48 |              << this->ncp_local_mttkrp_t[mode].cols(spanStart, spanEnd)
49 |              << std::endl;
50 |         }
51 | #endif
52 | 
53 |         subProblem.solveNNLS();
54 | 
55 | #ifdef _VERBOSE
56 |         INFO << "completed " << worh << " start=" << spanStart
57 |            << ", end=" << spanEnd
58 |            // << ", tid=" << omp_get_thread_num() << " cpu=" << sched_getcpu()
59 |            << " time taken=" << t2 << std::endl;
60 | #endif
61 |         othermat.cols(spanStart, spanEnd) = subProblem.getSolutionMatrix();
62 |       }
63 |     } else {
64 |       othermat.zeros();
65 |     }
66 |     return othermat;
67 |   }
68 | 
69 |  public:
70 |   DistNTFANLSBPP(const Tensor &i_tensor, const int i_k, algotype i_algo,
71 |                  const UVEC &i_global_dims, const UVEC &i_local_dims,
72 |                  const UVEC &i_nls_sizes, const UVEC &i_nls_idxs,
73 |                  const NTFMPICommunicator &i_mpicomm)
74 |       : DistAUNTF(i_tensor, i_k, i_algo, i_global_dims, i_local_dims,
75 |                   i_nls_sizes, i_nls_idxs, i_mpicomm) {}
76 | };  // class DistNTFANLSBPP
77 | 
78 | }  // namespace planc
79 | 
80 | #endif  // DISTNTF_DISTNTFANLSBPP_HPP_
81 | 


--------------------------------------------------------------------------------
/papers.md:
--------------------------------------------------------------------------------
 1 | # Papers
 2 | For more information on the different algorithms and implementations in PLANC please refer to the following papers.  
 3 | * Srinivas Eswar, Benjamin Cobb, Koby Hayashi, Ramakrishnan Kannan, Grey Ballard, Richard Vuduc, and Haesun Park. 2023. Distributed-Memory Parallel JointNMF. In Proceedings of the 37th International Conference on Supercomputing (ICS '23). Association for Computing Machinery, New York, NY, USA, 301–312. [[doi]](https://doi.org/10.1145/3577193.3593733)
 4 | * Srinivas Eswar. "Scalable Data Mining via Constrained Low Rank Approximation." (Doctoral Disseration) (2022). [[link]](http://hdl.handle.net/1853/67334)
 5 | * Srinivas Eswar, Koby Hayashi, Grey Ballard, Ramakrishnan Kannan, Michael A. Matheson, and Haesun Park. 2021. PLANC: Parallel Low-rank Approximation with Nonnegativity Constraints. ACM Trans. Math. Softw. 47, 3, Article 20 (September 2021), 37 pages. [[doi]](https://doi.org/10.1145/3432185)
 6 | *  Lawton Manning, Grey Ballard, Ramakrishnan Kannan, and Haesun Park, "Parallel Hierarchical Clustering using Rank-Two Nonnegative Matrix Factorization," 2020 IEEE 27th International Conference on High Performance Computing, Data, and Analytics (HiPC), Pune, India, 2020, pp. 141-150. [[doi]](https://doi.org/10.1109/HiPC50609.2020.00028)
 7 | * Srinivas Eswar, Koby Hayashi, Grey Ballard, Ramakrishnan Kannan, Richard Vuduc, and Haesun Park, "Distributed-Memory Parallel Symmetric Nonnegative Matrix Factorization," SC20: International Conference for High Performance Computing, Networking, Storage and Analysis, Atlanta, GA, USA, 2020, pp. 1-14. [[doi]](https://doi.org/10.1109/SC41405.2020.00078)
 8 | * Grey Ballard, Koby Hayashi and Ramakrishnan Kannan, "Parallel Nonnegative CP Decomposition of Dense Tensors," 2018 IEEE 25th International Conference on High Performance Computing (HiPC), Bengaluru, India, 2018, pp. 22-31. [[doi]](https://doi.org/10.1109/HiPC.2018.00012)
 9 | * Oguz Kaya, Ramakrishnan Kannan, and Grey Ballard. 2018. Partitioning and Communication Strategies for Sparse Non-negative Matrix Factorization. In Proceedings of the 47th International Conference on Parallel Processing (ICPP '18). Association for Computing Machinery, New York, NY, USA, Article 90, 1–10. [[doi]](https://doi.org/10.1145/3225058.3225127)
10 | * Ramakrishnan Kannan, Grey Ballard and Haesun Park, "MPI-FAUN: An MPI-Based Framework for Alternating-Updating Nonnegative Matrix Factorization," in IEEE Transactions on Knowledge and Data Engineering, vol. 30, no. 3, pp. 544-558, 1 March 2018. [[doi]](https://doi.org/10.1109/TKDE.2017.2767592)
11 | * Ramakrishnan Kannan, Grey Ballard, and Haesun Park. 2016. A high-performance parallel algorithm for nonnegative matrix factorization. In Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP '16). Association for Computing Machinery, New York, NY, USA, Article 9, 1–11. [[doi]](https://doi.org/10.1145/2851141.2851152)
12 | * Ramakrishnan Kannan. "Scalable and Distributed Constrained Low Rank Approximations." (Doctoral Disseration) (2016). [[link]](http://hdl.handle.net/1853/54962)


--------------------------------------------------------------------------------
/distntf/README.md:
--------------------------------------------------------------------------------
 1 | # MPI Based DistNTF
 2 | 
 3 | ## Install Instructions
 4 | 
 5 | This program depends on:
 6 | 
 7 | - [Armadillo](https://arma.sourceforge.net) library for linear algebra operations.
 8 | - [OpenBLAS](https://github.com/xianyi/OpenBLAS) for optimized kernels. If building with OpenBLAS and MKL is discoverable by `cmake`, use `-DCMAKE_IGNORE_MKL=1` while building. 
 9 | 
10 | Once the above steps are completed, set the following environment variables.
11 | 
12 | ````
13 | export ARMADILLO_INCLUDE_DIR=/home/rnu/libraries/armadillo-6.600.5/include/
14 | export LIB=$LIB:/home/rnu/libraries/openblas/lib:
15 | export INCLUDE=$INCLUDE:/home/rnu/libraries/openblas/include:$ARMADILLO_INCLUDE_DIR:
16 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/rnu/libraries/openblas/lib/:
17 | export NMFLIB_DIR=/ccs/home/ramki/rhea/research/nmflib/
18 | export INCLUDE=$INCLUDE:$ARMADILLO_INCLUDE_DIR:$NMFLIB_DIR
19 | export CPATH=$CPATH:$INCLUDE:
20 | export MKLROOT=/ccs/compilers/intel/rh6-x86_64/16.0.0/mkl/
21 | ````
22 | If you have got MKL, please source `mklvars.sh` before running `make`/`cmake`
23 | 
24 | * Create a build directory. 
25 | * Change to the build directory 
26 | * In case of MKL, `source` the ````$MKLROOT/bin/mkl_vars.sh intel64````
27 | * run `cmake` [PATH TO THE CMakeList.txt]. 
28 | * `make`
29 | 
30 | Refer to the build scripts found in the [build](build/README.md) directory for a sample script.
31 | 
32 | ### Input types
33 | PLANC only supports dense input tensors.
34 | 
35 | ### Other Macros
36 | 
37 | `cmake` macros
38 | 2. `-DCMAKE_BUILD_TYPE=Debug`: For creating debug builds.
39 | 3. `-DCMAKE_WITH_BARRIER_TIMING`: Default is set to barrier timing. To disable build with `-DCMAKE_WITH_BARRIER_TIMING:BOOL=OFF`.
40 | 4. `-DCMAKE_BUILD_CUDA`: Default is off.
41 | 5. `-DCMAKE_IGNORE_MKL`: Ignores MKL when discoverable by `cmake`. If using OpenBLAS, set `-DCMAKE_IGNORE_MKL=1` while building.
42 | 
43 | Code level macros - Defined in distutils.h
44 | 1. `MPI_VERBOSE` - Be **doubly sure** about what you do. It prints all intermediary matrices. Try this only for very very small tensors that is of size less than 10.
45 | 2. `WRITE_RAND_INPUT` - for dumping the generated random tensor.
46 | 
47 | ### IO options
48 | 
49 | PLANC uses MPI-IO to read in dense input tensors.
50 | 
51 | PLANC uses MPI-IO for outputting the factor matrices into a single file per factor matrix.
52 | 
53 | ## Command Line options
54 | For a full list of command line options please run `distntf -h`. Some common options are listed below.
55 | * `-p` Sets the processor grid dimensions.
56 | * `-k` Sets the low-rank parameter for the approximation.
57 | * `-d` Sets the input dimensions.
58 | * `-e` Switch to toggle error calculation. Off by default.
59 | * `-t` Maximum number of iterations to run the algorithms for.
60 | * `-a` Algorithm to run.
61 | * `-i` Input tensor to run on. Can be a synthetic input via options `rand_lowrank`/`rand_uniform`/`rand_normal` or a path to a file.
62 | * `-dimtree` Toggles the dimension tree optimization to speedup MTTKRP calculations. On by default.
63 | 
64 | ## Citation
65 | 
66 | Please refer to the [papers](papers.md) section for the appropriate reports to cite.
67 | 


--------------------------------------------------------------------------------
/formatter/google_clang_format:
--------------------------------------------------------------------------------
 1 | ---
 2 | Language:        Cpp
 3 | # BasedOnStyle:  Google
 4 | AccessModifierOffset: -1
 5 | AlignAfterOpenBracket: Align
 6 | AlignConsecutiveAssignments: false
 7 | AlignConsecutiveDeclarations: false
 8 | AlignEscapedNewlinesLeft: true
 9 | AlignOperands:   true
10 | AlignTrailingComments: false 
11 | AllowAllParametersOfDeclarationOnNextLine: true
12 | AllowShortBlocksOnASingleLine: false
13 | AllowShortCaseLabelsOnASingleLine: false
14 | AllowShortFunctionsOnASingleLine: All
15 | AllowShortIfStatementsOnASingleLine: true
16 | AllowShortLoopsOnASingleLine: true
17 | AlwaysBreakAfterDefinitionReturnType: None
18 | AlwaysBreakAfterReturnType: None
19 | AlwaysBreakBeforeMultilineStrings: true
20 | AlwaysBreakTemplateDeclarations: true
21 | BinPackArguments: true
22 | BinPackParameters: true
23 | BraceWrapping:   
24 |   AfterClass:      false
25 |   AfterControlStatement: false
26 |   AfterEnum:       false
27 |   AfterFunction:   false
28 |   AfterNamespace:  false
29 |   AfterObjCDeclaration: false
30 |   AfterStruct:     false
31 |   AfterUnion:      false
32 |   BeforeCatch:     false
33 |   BeforeElse:      false
34 |   IndentBraces:    false
35 | BreakBeforeBinaryOperators: None
36 | BreakBeforeBraces: Attach
37 | BreakBeforeTernaryOperators: true
38 | BreakConstructorInitializersBeforeComma: false
39 | BreakAfterJavaFieldAnnotations: false
40 | BreakStringLiterals: true
41 | ColumnLimit:     80
42 | CommentPragmas: '/\*(.+\n.+)+\*/' 
43 | ConstructorInitializerAllOnOneLineOrOnePerLine: true
44 | ConstructorInitializerIndentWidth: 4
45 | ContinuationIndentWidth: 4
46 | Cpp11BracedListStyle: true
47 | DerivePointerAlignment: true
48 | DisableFormat:   false
49 | ExperimentalAutoDetectBinPacking: false
50 | ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
51 | IncludeCategories: 
52 |   - Regex:           '^<.*\.h>'
53 |     Priority:        1
54 |   - Regex:           '^<.*'
55 |     Priority:        2
56 |   - Regex:           '.*'
57 |     Priority:        3
58 | IncludeIsMainRegex: '([-_](test|unittest))?$'
59 | IndentCaseLabels: true
60 | IndentWidth:     2
61 | IndentWrappedFunctionNames: false
62 | JavaScriptQuotes: Leave
63 | JavaScriptWrapImports: true
64 | KeepEmptyLinesAtTheStartOfBlocks: false
65 | MacroBlockBegin: ''
66 | MacroBlockEnd:   ''
67 | MaxEmptyLinesToKeep: 1
68 | NamespaceIndentation: None
69 | ObjCBlockIndentWidth: 2
70 | ObjCSpaceAfterProperty: false
71 | ObjCSpaceBeforeProtocolList: false
72 | PenaltyBreakBeforeFirstCallParameter: 1
73 | PenaltyBreakComment: 300
74 | PenaltyBreakFirstLessLess: 120
75 | PenaltyBreakString: 1000
76 | PenaltyExcessCharacter: 1000000
77 | PenaltyReturnTypeOnItsOwnLine: 200
78 | PointerAlignment: Left
79 | ReflowComments:  false 
80 | SortIncludes:    true
81 | SpaceAfterCStyleCast: false
82 | SpaceBeforeAssignmentOperators: true
83 | SpaceBeforeParens: ControlStatements
84 | SpaceInEmptyParentheses: false
85 | SpacesBeforeTrailingComments: 2
86 | SpacesInAngles:  false
87 | SpacesInContainerLiterals: true
88 | SpacesInCStyleCastParentheses: false
89 | SpacesInParentheses: false
90 | SpacesInSquareBrackets: false
91 | Standard:        Auto
92 | TabWidth:        8
93 | UseTab:          Never
94 | ...
95 | 
96 | 


--------------------------------------------------------------------------------
/ntf/README.md:
--------------------------------------------------------------------------------
 1 | # OpenMP Based NTF
 2 | 
 3 | ## Install Instructions
 4 | 
 5 | This program depends on:
 6 | 
 7 | - [Armadillo](https://arma.sourceforge.net) library for linear algebra operations.
 8 | - [OpenBLAS](https://github.com/xianyi/OpenBLAS) for optimized kernels. If building with OpenBLAS and MKL is discoverable by `cmake`, use `-DCMAKE_IGNORE_MKL=1` while building. 
 9 | 
10 | Once the above steps are completed, set the following environment variables.
11 | 
12 | ````
13 | export ARMADILLO_INCLUDE_DIR=/home/rnu/libraries/armadillo-6.600.5/include/
14 | export LIB=$LIB:/home/rnu/libraries/openblas/lib:
15 | export INCLUDE=$INCLUDE:/home/rnu/libraries/openblas/include:$ARMADILLO_INCLUDE_DIR:
16 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/rnu/libraries/openblas/lib/:
17 | export NMFLIB_DIR=/ccs/home/ramki/rhea/research/nmflib/
18 | export INCLUDE=$INCLUDE:$ARMADILLO_INCLUDE_DIR:$NMFLIB_DIR
19 | export CPATH=$CPATH:$INCLUDE:
20 | export MKLROOT=/ccs/compilers/intel/rh6-x86_64/16.0.0/mkl/
21 | ````
22 | If you have got MKL, please source `mklvars.sh` before running `make`/`cmake`
23 | 
24 | * Create a build directory. 
25 | * Change to the build directory 
26 | * In case of MKL, `source` the ````$MKLROOT/bin/mkl_vars.sh intel64````
27 | * run `cmake` [PATH TO THE CMakeList.txt]. 
28 | * `make`
29 | 
30 | Refer to the build scripts found in the [build](build/README.md) directory for a sample script.
31 | 
32 | ### Input types
33 | PLANC only supports dense input tensors.
34 | 
35 | ### Other Macros
36 | 
37 | `cmake` macros
38 | 2. `-DCMAKE_BUILD_TYPE=Debug`: For creating debug builds.
39 | 3. `-DCMAKE_WITH_BARRIER_TIMING`: Default is set to barrier timing. To disable build with `-DCMAKE_WITH_BARRIER_TIMING:BOOL=OFF`.
40 | 4. `-DCMAKE_BUILD_CUDA`: Default is off.
41 | 5. `-DCMAKE_IGNORE_MKL`: Ignores MKL when discoverable by `cmake`. If using OpenBLAS, set `-DCMAKE_IGNORE_MKL=1` while building.
42 | 
43 | Code level macros - Defined in distutils.h
44 | 1. `MPI_VERBOSE` - Be **doubly sure** about what you do. It prints all intermediary matrices. Try this only for very very small tensors that is of size less than 10.
45 | 2. `WRITE_RAND_INPUT` - for dumping the generated random tensor.
46 | 
47 | ## Runtime usage
48 | 
49 | Tell OpenBlas how many threads you want to use. For example on a quad core system use the following.
50 | 
51 | ```
52 | export OPENBLAS_NUM_THREADS=4
53 | export MKL_NUM_THREADS=4
54 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:MKL_LIB
55 | ```
56 | 
57 | ## Command Line options
58 | For a full list of command line options please run `ntf -h`. Some common options are listed below.
59 | * `-k` Sets the low-rank parameter for the approximation.
60 | * `-d` Sets the input dimensions.
61 | * `-e` Switch to toggle error calculation. Off by default.
62 | * `-t` Maximum number of iterations to run the algorithms for.
63 | * `-a` Algorithm to run.
64 | * `-i` Input tensor to run on. Can be a synthetic input via options `rand_lowrank`/`rand_uniform`/`rand_normal` or a path to a file.
65 | * `-dimtree` Toggles the dimension tree optimization to speedup MTTKRP calculations. On by default.
66 | 
67 | ## Citation
68 | 
69 | Please refer to the [papers](papers.md) section for the appropriate reports to cite.
70 | 


--------------------------------------------------------------------------------
/nmf/mu.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright 2016 Ramakrishnan Kannan */
 2 | 
 3 | #ifndef NMF_MU_HPP_
 4 | #define NMF_MU_HPP_
 5 | 
 6 | #include "common/nmf.hpp"
 7 | 
 8 | namespace planc {
 9 | 
10 | template <class T>
11 | class MUNMF : public NMF<T> {
12 |  private:
13 |   // Not happy with this design. However to avoid computing At again and again
14 |   // making this as private variable.
15 |   T At;
16 |   MAT WtW;
17 |   MAT HtH;
18 |   MAT AtW;
19 |   MAT AH;
20 | 
21 |   /*
22 |    * Collected statistics are
23 |    * iteration Htime Wtime totaltime normH normW densityH densityW relError
24 |    */
25 |   void allocateMatrices() {
26 |     WtW = arma::zeros<MAT>(this->k, this->k);
27 |     HtH = arma::zeros<MAT>(this->k, this->k);
28 |     AtW = arma::zeros<MAT>(this->n, this->k);
29 |     AH = arma::zeros<MAT>(this->m, this->k);
30 |   }
31 |   void freeMatrices() {
32 |     this->At.clear();
33 |     WtW.clear();
34 |     HtH.clear();
35 |     AtW.clear();
36 |     AH.clear();
37 |   }
38 | 
39 |  public:
40 |   MUNMF(const T &A, int lowrank) : NMF<T>(A, lowrank) {
41 |     allocateMatrices();
42 |     this->At = this->A.t();
43 |   }
44 |   MUNMF(const T &A, const MAT &llf, const MAT &rlf) : NMF<T>(A, llf, rlf) {
45 |     allocateMatrices();
46 |     this->At = this->A.t();
47 |   }
48 |   void computeNMF() {
49 |     unsigned int currentIteration = 0;
50 |     INFO << "computed transpose At=" << PRINTMATINFO(this->At) << std::endl;
51 |     while (currentIteration < this->num_iterations()) {
52 |       tic();
53 |       // update H
54 |       tic();
55 |       AtW = this->At * this->W;
56 |       WtW = this->W.t() * this->W;
57 |       this->applyReg(this->regH(), &this->WtW);
58 |       INFO << "starting H Prereq for "
59 |            << " took=" << toc();
60 |       INFO << PRINTMATINFO(WtW) << PRINTMATINFO(AtW) << std::endl;
61 |       // to avoid divide by zero error.
62 |       tic();
63 |       // H = H.*AtW./(WtW_reg*H + epsilon);
64 |       this->H = (this->H % AtW) / (this->H * WtW + EPSILON_1EMINUS16);
65 |       INFO << "Completed H (" << currentIteration << "/"
66 |            << this->num_iterations() << ")"
67 |            << " time =" << toc() << std::endl;
68 | 
69 |       // update W;
70 |       tic();
71 |       AH = this->A * this->H;
72 |       HtH = this->H.t() * this->H;
73 |       this->applyReg(this->regW(), &this->HtH);
74 |       INFO << "starting W Prereq for "
75 |            << " took=" << toc() << PRINTMATINFO(HtH) << PRINTMATINFO(AH)
76 |            << std::endl;
77 |       tic();
78 |       // W = W.*AH./(W*HtH_reg + epsilon);
79 |       this->W = (this->W % AH) / ((this->W * HtH) + EPSILON_1EMINUS16);
80 |       INFO << "Completed W (" << currentIteration << "/"
81 |            << this->num_iterations() << ")"
82 |            << " time =" << toc() << std::endl;
83 |       INFO << "Completed It (" << currentIteration << "/"
84 |            << this->num_iterations() << ")"
85 |            << " time =" << toc() << std::endl;
86 |       this->computeObjectiveError();
87 |       this->printObjective(currentIteration);
88 |       currentIteration++;
89 |     }
90 |     this->normalize_by_W();
91 |   }
92 |   ~MUNMF() { freeMatrices(); }
93 | };
94 | 
95 | }  // namespace planc
96 | 
97 | #endif  // NMF_MU_HPP_
98 | 


--------------------------------------------------------------------------------
/distnmf/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #Copyright 2016 Ramakrishnan Kannan
 2 | 
 3 | cmake_minimum_required(VERSION 3.6 FATAL_ERROR)
 4 | 
 5 | set(ARMA_USE_WRAPPER true)
 6 | 
 7 | # the settings below will be automatically configured by the rest of this script
 8 | 
 9 | # set(ARMADILLO_LIB_DIR /home/okaya/armadillo-6.600.5/install/usr/lib)
10 | 
11 | project(DISTNMF CXX)
12 | 
13 | set(NMFLIB_COMMON ${DISTNMF_SOURCE_DIR}/../common)
14 | set(NNLS_SRC ${DISTNMF_SOURCE_DIR}/../nnls/)
15 | message(STATUS "DISTNMF_SOURCE_DIR =  ${DISTNMF_SOURCE_DIR}")
16 | message(STATUS "NMFLIB_COMMON =  ${NMFLIB_COMMON}")
17 | 
18 | include(${NMFLIB_COMMON}/cmake_aux/NMFLIB_FindARMA.cmake)
19 | 
20 | #BOOST package needed for activeset NNLS
21 | #set(BOOST false)
22 | #As advised by Wlliam Renaud note dated 4/22. There is an issue on Rhea
23 | #in which the system boost is found before the version in modules.
24 | #Ignore system boost and use module system boost
25 | #set(Boost_NO_BOOST_CMAKE TRUE)
26 | #find_package(Boost REQUIRED)
27 | 
28 | find_package(MPI REQUIRED)
29 | 
30 | message(STATUS " MPI_CXX_FOUND = ${MPI_CXX_FOUND}" )
31 | 
32 | if(MPI_CXX_FOUND)
33 |   set(NMFLIB_LIBS ${NMFLIB_LIBS} ${MPI_CXX_LIBRARIES})
34 | endif()
35 | 
36 | OPTION(CMAKE_BUILD_PACOSS "Build with PACOSS" OFF)
37 | if(CMAKE_WITH_PACOSS)
38 |   add_definitions(-DUSE_PACOSS=1)
39 |   set(PACOSS_DIR ${DISTNMF_SOURCE_DIR}/../pacoss)
40 |   set(PACOSS_INCLUDE_DIR ${DISTNMF_SOURCE_DIR}/../pacoss/src) 
41 |   set(PACOSS_INCLUDE_DIR ${PACOSS_INCLUDE_DIR} ${DISTNMF_SOURCE_DIR}/../tmpi/src)
42 |   set(PACOSS_LIB_DIR ${DISTNMF_SOURCE_DIR}/../pacoss/lib)
43 |   link_directories(
44 |     ${PACOSS_LIB_DIR}  
45 |   )
46 |   set(NMFLIB_LIBS "${NMFLIB_LIBS} pacoss")
47 | endif()
48 | 
49 | set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g3 -O0 -rdynamic")
50 | 
51 | message(STATUS "CMAKE_CXX_FLAGS           = ${CMAKE_CXX_FLAGS}"          )
52 | message(STATUS "CMAKE_SHARED_LINKER_FLAGS = ${CMAKE_SHARED_LINKER_FLAGS}")
53 | message(STATUS "CMAKE_REQUIRED_INCLUDES   = ${CMAKE_REQUIRED_INCLUDES}"  )
54 | 
55 | message(STATUS "")
56 | message(STATUS "*** libraries:")
57 | message(STATUS "*** NMFLIB_LIBS = ${NMFLIB_LIBS}")
58 | message(STATUS "")
59 | 
60 | include_directories(
61 |   ${PACOSS_INCLUDE_DIR}
62 |   ${ARMADILLO_INCLUDE_DIR}
63 |   ${ARMADILLO_INCLUDE_DIRS}
64 |   ${DISTNMF_SOURCE_DIR}
65 |   ${DISTNMF_SOURCE_DIR}/../
66 |   ${NMFLIB_COMMON}
67 |   ${NNLS_SRC}
68 |   ${MPI_CXX_INCLUDE_PATH}
69 |   ${MKL_INCLUDE_DIR}
70 |   ${OPENBLAS_INCLUDE_DIR}
71 | )
72 | 
73 | if(CMAKE_WITH_PACOSS)
74 |   set(DENSE_OR_SPARSE sparse)
75 |   add_executable(sparse_distnmf
76 |     distnmf.cpp
77 |   )
78 |   target_link_libraries(sparse_distnmf ${NMFLIB_LIBS} pacoss)
79 | elseif(CMAKE_BUILD_SPARSE)
80 |   set(DENSE_OR_SPARSE sparse)
81 |   add_executable(sparse_distnmf
82 |     distnmf.cpp
83 |   )
84 |   target_link_libraries(sparse_distnmf ${NMFLIB_LIBS})
85 | else()
86 |   set(DENSE_OR_SPARSE dense)
87 |   add_executable(dense_distnmf
88 |     distnmf.cpp
89 |   )
90 |   target_link_libraries(dense_distnmf ${NMFLIB_LIBS})
91 | endif()
92 | 
93 | install(TARGETS ${DENSE_OR_SPARSE}_distnmf
94 |         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
95 |         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
96 |         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )


--------------------------------------------------------------------------------
/hiernmf/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #Copyright 2016 Ramakrishnan Kannan
 2 | 
 3 | cmake_minimum_required(VERSION 3.6 FATAL_ERROR)
 4 | 
 5 | set(ARMA_USE_WRAPPER true)
 6 | 
 7 | # the settings below will be automatically configured by the rest of this script
 8 | 
 9 | # set(ARMADILLO_LIB_DIR /home/okaya/armadillo-6.600.5/install/usr/lib)
10 | 
11 | project(HIERNMF CXX)
12 | 
13 | set(NMFLIB_COMMON ${HIERNMF_SOURCE_DIR}/../common)
14 | set(NNLS_SRC ${HIERNMF_SOURCE_DIR}/../nnls/)
15 | message(STATUS "HIERNMF_SOURCE_DIR =  ${HIERNMF_SOURCE_DIR}")
16 | message(STATUS "NMFLIB_COMMON =  ${NMFLIB_COMMON}")
17 | 
18 | include(${NMFLIB_COMMON}/cmake_aux/NMFLIB_FindARMA.cmake)
19 | 
20 | #BOOST package needed for activeset NNLS
21 | #set(BOOST false)
22 | #As advised by Wlliam Renaud note dated 4/22. There is an issue on Rhea
23 | #in which the system boost is found before the version in modules.
24 | #Ignore system boost and use module system boost
25 | #set(Boost_NO_BOOST_CMAKE TRUE)
26 | #find_package(Boost REQUIRED)
27 | 
28 | find_package(MPI REQUIRED)
29 | 
30 | message(STATUS " MPI_CXX_FOUND = ${MPI_CXX_FOUND}" )
31 | 
32 | if(MPI_CXX_FOUND)
33 |   set(NMFLIB_LIBS ${NMFLIB_LIBS} ${MPI_CXX_LIBRARIES})
34 | endif()
35 | 
36 | OPTION(CMAKE_BUILD_PACOSS "Build with PACOSS" OFF)
37 | if(CMAKE_WITH_PACOSS)
38 |   add_definitions(-DUSE_PACOSS=1)
39 |   set(PACOSS_DIR ${DISTNMF_SOURCE_DIR}/../pacoss)
40 |   set(PACOSS_INCLUDE_DIR ${DISTNMF_SOURCE_DIR}/../pacoss/src) 
41 |   set(PACOSS_INCLUDE_DIR ${PACOSS_INCLUDE_DIR} ${DISTNMF_SOURCE_DIR}/../tmpi/src)
42 |   set(PACOSS_LIB_DIR ${DISTNMF_SOURCE_DIR}/../pacoss/lib)
43 |   link_directories(
44 |     ${PACOSS_LIB_DIR}  
45 |   )
46 |   set(NMFLIB_LIBS "${NMFLIB_LIBS} pacoss")
47 | endif()
48 | 
49 | set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g3 -O0 -rdynamic")
50 | 
51 | message(STATUS "CMAKE_CXX_FLAGS           = ${CMAKE_CXX_FLAGS}"          )
52 | message(STATUS "CMAKE_SHARED_LINKER_FLAGS = ${CMAKE_SHARED_LINKER_FLAGS}")
53 | message(STATUS "CMAKE_REQUIRED_INCLUDES   = ${CMAKE_REQUIRED_INCLUDES}"  )
54 | 
55 | message(STATUS "")
56 | message(STATUS "*** libraries:")
57 | message(STATUS "*** NMFLIB_LIBS = ${NMFLIB_LIBS}")
58 | message(STATUS "")
59 | 
60 | include_directories(
61 |   ${PACOSS_INCLUDE_DIR}
62 |   ${ARMADILLO_INCLUDE_DIR}
63 |   ${ARMADILLO_INCLUDE_DIRS}
64 |   ${HIERNMF_SOURCE_DIR}
65 |   ${HIERNMF_SOURCE_DIR}/../
66 |   ${NMFLIB_COMMON}
67 |   ${NNLS_SRC}
68 |   ${MPI_CXX_INCLUDE_PATH}
69 |   ${MKL_INCLUDE_DIR}
70 |   ${OPENBLAS_INCLUDE_DIR}
71 | )
72 | 
73 | if(CMAKE_WITH_PACOSS)
74 |   set(DENSE_OR_SPARSE sparse)
75 |   add_executable(sparse_hiernmf
76 |     hiernmf.cpp
77 |   )
78 |   target_link_libraries(sparse_hiernmf ${NMFLIB_LIBS} pacoss)
79 | elseif(CMAKE_BUILD_SPARSE)
80 |   set(DENSE_OR_SPARSE sparse)
81 |   add_executable(sparse_hiernmf
82 |     hiernmf.cpp
83 |   )
84 |   target_link_libraries(sparse_hiernmf ${NMFLIB_LIBS})
85 | else()
86 |   set(DENSE_OR_SPARSE dense)
87 |   add_executable(dense_hiernmf
88 |     hiernmf.cpp
89 |   )
90 |   target_link_libraries(dense_hiernmf ${NMFLIB_LIBS})
91 | endif()
92 | 
93 | install(TARGETS ${DENSE_OR_SPARSE}_hiernmf
94 |         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
95 |         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
96 |         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )
97 | 


--------------------------------------------------------------------------------
/testcases.md:
--------------------------------------------------------------------------------
 1 | # Testcases
 2 | 
 3 | Sample test cases to execute are. You should see the error going down. We also tested the scaling up on a relatively small size of matrix say 20000 by 10000 of dense. The scale out on large number of cluster with big size matrix also works good. Ensure that the objective error is decreasing at every iteration. 
 4 | 
 5 | Openmp Dense NMF:
 6 | =================
 7 | ```
 8 | for a in 0 1 2 4 
 9 | do
10 | ./dense_nmf -d "2000 2000" -t 10 -k 10 -a $a -e 1 -i rand_lowrank
11 | done
12 | ./dense_nmf -d "100 100" -k 10 -t 10 -e 1 -a 2 --symm 0.0 -i rand_lowrank
13 | ./dense_nmf -d "100 100" -k 10 -t 10 -e 1 -a 7 --symm 0.0 -i rand_lowrank
14 | ```
15 | 
16 | Openmp Dense NTF:
17 | =================
18 | ```
19 | for a in 0 1 2 4 5
20 | do
21 | ./dense_ntf -d "200 200 200" -t 10 -k 10 -a $a -e 1 -i rand_lowrank
22 | done
23 | ```
24 | 
25 | Openmp Sparse NMF:
26 | =================
27 | ```
28 | for a in 0 1 2 4 
29 | do
30 | ./sparse_nmf -d "2000 2000" -t 10 -k 10 -a $a -e 1 -i rand_lowrank -s 0.01
31 | done
32 | ./sparse_nmf -d "100 100" -k 10 -t 10 -e 1 -a 2 --symm 0.0 -i rand_lowrank -s 0.05
33 | ./sparse_nmf -d "100 100" -k 10 -t 10 -e 1 -a 7 --symm 0.0 -i rand_lowrank -s 0.05
34 | ```
35 | Dist Dense NMF:
36 | ================
37 | ```
38 | for a in 0 1 2 4 
39 | do
40 | mpirun -np 16 ./dense_distnmf -d "2000 2000" -p "4 4" -t 10 -k 10 -a $a -e 1 -i rand_lowrank
41 | mpirun -np 16 ./dense_distnmf -d "2000 2000" -p "8 2" -t 10 -k 10 -a $a -e 1 -i rand_lowrank
42 | mpirun -np 16 ./dense_distnmf -d "1500 1000" -p "4 4" -t 10 -k 10 -a $a -e 1 -i rand_lowrank
43 | mpirun -np 16 ./dense_distnmf -d "1500 1000" -p "8 2" -t 10 -k 10 -a $a -e 1 -i rand_lowrank
44 | done
45 | mpirun -np 16 ./dense_distnmf -d "2000 2000" -p "4 4" -t 10 -k 10 -a 2 -e 1 -i rand_lowrank --symm 0.0
46 | mpirun -np 16 ./dense_distnmf -d "2000 2000" -p "4 4" -t 10 -k 10 -a 7 -e 1 -i rand_lowrank --symm 0.0
47 | mpirun -np 16 ./dense_distnmf -d "830 830" -p "4 4" -t 10 -k 10 -a 2 -e 1 -i rand_lowrank --symm 0.0
48 | mpirun -np 16 ./dense_distnmf -d "830 830" -p "4 4" -t 10 -k 10 -a 7 -e 1 -i rand_lowrank --symm 0.0
49 | ```
50 | 
51 | 
52 | Dist Sparse NMF:
53 | ===============
54 | ```
55 | for a in 0 1 2 4 
56 | do
57 | mpirun -np 16 ./sparse_distnmf -d "2000 2000" -p "4 4" -t 10 -k 10 -a $a -e 1 -i rand_lowrank -s 0.01
58 | mpirun -np 16 ./sparse_distnmf -d "2000 2000" -p "8 2" -t 10 -k 10 -a $a -e 1 -i rand_lowrank -s 0.01
59 | mpirun -np 16 ./sparse_distnmf -d "1500 1000" -p "4 4" -t 10 -k 10 -a $a -e 1 -i rand_lowrank -s 0.01
60 | mpirun -np 16 ./sparse_distnmf -d "1500 1000" -p "8 2" -t 10 -k 10 -a $a -e 1 -i rand_lowrank -s 0.01
61 | done
62 | mpirun -np 16 ./sparse_distnmf -d "2000 2000" -p "4 4" -t 10 -k 10 -a 2 -e 1 -i rand_lowrank -s 0.01 --symm 0.0
63 | mpirun -np 16 ./sparse_distnmf -d "2000 2000" -p "4 4" -t 10 -k 10 -a 7 -e 1 -i rand_lowrank -s 0.01 --symm 0.0
64 | mpirun -np 16 ./sparse_distnmf -d "830 830" -p "4 4" -t 10 -k 10 -a 2 -e 1 -i rand_lowrank -s 0.01 --symm 0.0
65 | mpirun -np 16 ./sparse_distnmf -d "830 830" -p "4 4" -t 10 -k 10 -a 7 -e 1 -i rand_lowrank -s 0.01 --symm 0.0
66 | ```
67 | 
68 | Dist Dense NTF:
69 | ===============
70 | ```
71 | for a in 0 1 2 4 5
72 | do
73 | mpirun -np 9 ./dense_ntf -d "200 200 200" -p "3 3 3" -t 10 -k 10 -a $a -e 1 -i rand_lowrank --dimtree 1 
74 | done
75 | ```


--------------------------------------------------------------------------------
/distjointnmf/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #Copyright 2022 Ramakrishnan Kannan
 2 | 
 3 | cmake_minimum_required(VERSION 3.6 FATAL_ERROR)
 4 | 
 5 | set(ARMA_USE_WRAPPER true)
 6 | 
 7 | project(DISTJOINTNMF CXX)
 8 | 
 9 | set(NMFLIB_COMMON ${DISTJOINTNMF_SOURCE_DIR}/../common)
10 | set(NNLS_SRC ${DISTJOINTNMF_SOURCE_DIR}/../nnls/)
11 | message(STATUS "DISTJOINTNMF_SOURCE_DIR =  ${DISTJOINTNMF_SOURCE_DIR}")
12 | message(STATUS "NMFLIB_COMMON =  ${NMFLIB_COMMON}")
13 | 
14 | include(${NMFLIB_COMMON}/cmake_aux/NMFLIB_FindARMA.cmake)
15 | 
16 | find_package(MPI REQUIRED)
17 | 
18 | message(STATUS " MPI_CXX_FOUND = ${MPI_CXX_FOUND}" )
19 | 
20 | if(MPI_CXX_FOUND)
21 |   set(NMFLIB_LIBS ${NMFLIB_LIBS} ${MPI_CXX_LIBRARIES})
22 | endif()
23 | 
24 | set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g3 -O0 -rdynamic")
25 | 
26 | message(STATUS "CMAKE_CXX_FLAGS           = ${CMAKE_CXX_FLAGS}"          )
27 | message(STATUS "CMAKE_SHARED_LINKER_FLAGS = ${CMAKE_SHARED_LINKER_FLAGS}")
28 | message(STATUS "CMAKE_REQUIRED_INCLUDES   = ${CMAKE_REQUIRED_INCLUDES}"  )
29 | 
30 | message(STATUS "")
31 | message(STATUS "*** libraries:")
32 | message(STATUS "*** NMFLIB_LIBS = ${NMFLIB_LIBS}")
33 | message(STATUS "")
34 | 
35 | include_directories(
36 |   ${ARMADILLO_INCLUDE_DIR}
37 |   ${ARMADILLO_INCLUDE_DIRS}
38 |   ${DISTJOINTNMF_SOURCE_DIR}
39 |   ${DISTJOINTNMF_SOURCE_DIR}/../
40 |   ${NMFLIB_COMMON}
41 |   ${NNLS_SRC}
42 |   ${MPI_CXX_INCLUDE_PATH}
43 |   ${MKL_INCLUDE_DIR}
44 |   ${OPENBLAS_INCLUDE_DIR}
45 | )
46 | 
47 | # set(BLA_VENDOR Intel)
48 | if (ENABLE_MKL AND MKL_LIBS)
49 |   message(STATUS "ENABLED MKL AT: ${MKL_LIBS}")
50 |   add_compile_definitions(MKL_FOUND)
51 |   set(BLAS_LIBRARIES ${MKL_LIBS}:${BLAS_LIBRARIES})
52 | elseif (ENABLE_MKL AND NOT MKL_LIBS)
53 |   message(STATUS "ENABLED MKL, BUT MKL PATH NOT PROVIDED. SEARCHING FOR MKL WITH FIND_LIBRARY")
54 |   FIND_LIBRARY(MKL 
55 |     NAMES mkl 
56 |     HINTS [${MKLROOT}, ${MKL_ROOT}])
57 | 
58 |   message(STATUS MKL: ${MKL})
59 | 
60 |   if (${MKL} STREQUAL MKL-NOTFOUND)
61 |     message(STATUS "UNABLE TO FIND MKL, CONTINUING ON WITHOUT IT")
62 |   else ()
63 |     message(STATUS "FOUND MKL AT: ${MKL}") #${MKL_LIBS}
64 |     add_compile_definitions(MKL_FOUND)
65 |     set(BLAS_LIBRARIES ${MKL}:${BLAS_LIBRARIES})
66 |   endif (${MKL} STREQUAL MKL-NOTFOUND)
67 |   
68 | else (NOT ENABLE_MKL)
69 |   message(STATUS "MKL WAS NOT ENABLED")
70 | endif (ENABLE_MKL AND MKL_LIBS)
71 | 
72 | # Check Barrier timings
73 | if(CMAKE_WITH_BARRIER_TIMING)
74 |   message(STATUS "MPI Barrier timings enabled.")
75 | endif()
76 | 
77 | if(CMAKE_BUILD_SPDEN)
78 |   add_definitions(-DBUILD_SPDEN=1)
79 |   set(JNMF_TYPE spden_)
80 | elseif(CMAKE_BUILD_DENSP)
81 |   add_definitions(-DBUILD_DENSP=1)
82 |   set(JNMF_TYPE densp_)
83 | elseif(CMAKE_BUILD_DENDEN)
84 |   add_definitions(-DBUILD_DENDEN=1)
85 |   set(JNMF_TYPE denden_)
86 | elseif(CMAKE_BUILD_SPSP)
87 |   add_definitions(-DBUILD_SPSP=1)
88 |   set(JNMF_TYPE spsp_)
89 | else()
90 |   set(JNMF_TYPE)
91 | endif()
92 | 
93 | add_executable(${JNMF_TYPE}distjointnmf distjointnmf.cpp)
94 | target_link_libraries(${JNMF_TYPE}distjointnmf ${NMFLIB_LIBS})
95 | 
96 | install(TARGETS ${JNMF_TYPE}distjointnmf
97 |         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
98 |         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
99 |         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )


--------------------------------------------------------------------------------
/nmf/README.md:
--------------------------------------------------------------------------------
 1 | # OpenMP NMF
 2 | 
 3 | ## Install Instructions
 4 | 
 5 | This program depends on:
 6 | 
 7 | - [Armadillo](https://arma.sourceforge.net) library for linear algebra operations.
 8 | - [OpenBLAS](https://github.com/xianyi/OpenBLAS) for optimized kernels. If building with OpenBLAS and MKL is discoverable by `cmake`, use `-DCMAKE_IGNORE_MKL=1` while building. 
 9 | 
10 | Once the above steps are completed, set the following environment variables.
11 | 
12 | ````
13 | export ARMADILLO_INCLUDE_DIR=/home/rnu/libraries/armadillo-6.600.5/include/
14 | export LIB=$LIB:/home/rnu/libraries/openblas/lib:
15 | export INCLUDE=$INCLUDE:/home/rnu/libraries/openblas/include:$ARMADILLO_INCLUDE_DIR:
16 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/rnu/libraries/openblas/lib/:
17 | export NMFLIB_DIR=/ccs/home/ramki/rhea/research/nmflib/
18 | export INCLUDE=$INCLUDE:$ARMADILLO_INCLUDE_DIR:$NMFLIB_DIR
19 | export CPATH=$CPATH:$INCLUDE:
20 | export MKLROOT=/ccs/compilers/intel/rh6-x86_64/16.0.0/mkl/
21 | ````
22 | If you have got MKL, please source `mklvars.sh` before running `make`/`cmake`
23 | 
24 | * Create a build directory. 
25 | * Change to the build directory 
26 | * In case of MKL, `source` the ````$MKLROOT/bin/mkl_vars.sh intel64````
27 | * run `cmake` [PATH TO THE CMakeList.txt]. 
28 | * `make`
29 | 
30 | Refer to the build scripts found in the [build](build/README.md) directory for a sample script.
31 | 
32 | ### Input types
33 | PLANC supports both dense and sparse input matrices via the `-DCMAKE_BUILD_SPARSE` flag. To generate a sparse build run the following command.
34 | ```
35 | cmake -DCMAKE_BUILD_SPARSE=1 [path to the CMakeLists.txt]
36 | ```
37 | ### Other Macros
38 | 
39 | `cmake` macros
40 | 1. `-DCMAKE_BUILD_SPARSE`: For handling sparse input matrices. Default is a dense build.
41 | 2. `-DCMAKE_BUILD_TYPE=Debug`: For creating debug builds.
42 | 3. `-DCMAKE_WITH_BARRIER_TIMING`: Default is set to barrier timing. To disable build with `-DCMAKE_WITH_BARRIER_TIMING:BOOL=OFF`.
43 | 4. `-DCMAKE_BUILD_CUDA`: Default is off.
44 | 5. `-DCMAKE_IGNORE_MKL`: Ignores MKL when discoverable by `cmake`. If using OpenBLAS, set `-DCMAKE_IGNORE_MKL=1` while building.
45 | 
46 | Code level macros - Defined in distutils.h
47 | 1. `MPI_VERBOSE` - Be **doubly sure** about what you do. It prints all intermediary matrices. Try this only for very very small matrix that is of size less than 10.
48 | 2. `WRITE_RAND_INPUT` - for dumping the generated random matrix.
49 | 
50 | ## Runtime usage
51 | 
52 | Tell OpenBlas how many threads you want to use. For example on a quad core system use the following.
53 | 
54 | ```
55 | export OPENBLAS_NUM_THREADS=4
56 | export MKL_NUM_THREADS=4
57 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:MKL_LIB
58 | ```
59 | 
60 | ## Command Line options
61 | For a full list of command line options please run `nmf -h`. Some common options are listed below.
62 | * `-k` Sets the low-rank parameter for the approximation.
63 | * `-d` Sets the input dimensions.
64 | * `-e` Switch to toggle error calculation. Off by default.
65 | * `-t` Maximum number of iterations to run the algorithms for.
66 | * `-a` Algorithm to run.
67 | * `-i` Input matrix to run on. Can be a synthetic input via options `rand_lowrank`/`rand_uniform`/`rand_normal` or a path to a file.
68 | 
69 | ## Citation
70 | 
71 | Please refer to the [papers](papers.md) section for the appropriate reports to cite.
72 | 


--------------------------------------------------------------------------------
/ntf/ntfaoadmm.hpp:
--------------------------------------------------------------------------------
 1 | /* Copyright Ramakrishnan Kannan 2018 */
 2 | 
 3 | #ifndef NTF_NTFAOADMM_HPP_
 4 | #define NTF_NTFAOADMM_HPP_
 5 | 
 6 | #include "ntf/auntf.hpp"
 7 | 
 8 | namespace planc {
 9 | 
10 | class NTFAOADMM : public AUNTF {
11 |  private:
12 |   // ADMM auxiliary variables
13 |   NCPFactors m_ncp_aux;
14 |   NCPFactors m_ncp_aux_t;
15 |   NCPFactors m_temp_ncp_aux_t;
16 |   MAT L;
17 |   MAT Lt;
18 |   MAT tempgram;
19 |   int admm_iter;
20 |   double tolerance;
21 | 
22 |  protected:
23 |   MAT update(const int mode) {
24 |     // return variable
25 |     MAT updated_fac(this->m_ncp_factors.factor(mode));
26 |     MAT prev_fac = updated_fac;
27 | 
28 |     // Set up ADMM iteration
29 |     double alpha =
30 |         arma::trace(this->gram_without_one) / this->m_ncp_factors.rank();
31 |     alpha = (alpha > 0) ? alpha : 0.01;
32 |     tempgram = this->gram_without_one;
33 |     tempgram.diag() += alpha;
34 |     L = arma::chol(tempgram, "lower");
35 |     Lt = L.t();
36 |     bool stop_iter = false;
37 | 
38 |     // Start ADMM loop from here
39 |     for (int i = 0; i < admm_iter && !stop_iter; i++) {
40 |       prev_fac = updated_fac;
41 |       m_ncp_aux_t.set(mode, m_ncp_aux.factor(mode).t());
42 | 
43 |       m_temp_ncp_aux_t.set(
44 |           mode, arma::solve(arma::trimatl(L),
45 |                             this->ncp_mttkrp_t[mode] +
46 |                                 (alpha * (updated_fac.t() +
47 |                                           m_ncp_aux_t.factor(mode)))));
48 |       m_ncp_aux_t.set(
49 |           mode, arma::solve(arma::trimatu(Lt), m_temp_ncp_aux_t.factor(mode)));
50 | 
51 |       // Update factor matrix
52 |       updated_fac = m_ncp_aux_t.factor(mode).t();
53 |       // Uncomment if numerical issues are seen
54 |       // fixNumericalError<MAT>(&(updated_fac), EPSILON_1EMINUS16, 0.0);
55 |       updated_fac = updated_fac - m_ncp_aux.factor(mode);
56 |       updated_fac.for_each(
57 |           [](MAT::elem_type &val) { val = val > 0.0 ? val : 0.0; });
58 | 
59 |       // Update dual variable
60 |       m_ncp_aux.set(mode, m_ncp_aux.factor(mode) + updated_fac -
61 |                               m_ncp_aux_t.factor(mode).t());
62 | 
63 |       // factor norm
64 |       double facnorm = arma::norm(updated_fac, "fro");
65 | 
66 |       // dual norm
67 |       double dualnorm = arma::norm(m_ncp_aux.factor(mode), "fro");
68 | 
69 |       // Check stopping criteria
70 |       double r = norm(updated_fac.t() - m_ncp_aux_t.factor(mode), "fro");
71 |       double s = norm(updated_fac - prev_fac, "fro");
72 |       if (r < (tolerance * facnorm) && s < (tolerance * dualnorm))
73 |         stop_iter = true;
74 |     }
75 |     m_ncp_aux.normalize(mode);
76 |     return updated_fac.t();
77 |   }
78 | 
79 |  public:
80 |   NTFAOADMM(const Tensor &i_tensor, const int i_k, algotype i_algo)
81 |       : AUNTF(i_tensor, i_k, i_algo),
82 |         m_ncp_aux(i_tensor.dimensions(), i_k, false),
83 |         m_ncp_aux_t(i_tensor.dimensions(), i_k, true),
84 |         m_temp_ncp_aux_t(i_tensor.dimensions(), i_k, true) {
85 |     m_ncp_aux.zeros();
86 |     m_ncp_aux_t.zeros();
87 |     m_temp_ncp_aux_t.zeros();
88 |     L.zeros(i_k, i_k);
89 |     Lt.zeros(i_k, i_k);
90 |     tempgram.zeros(i_k, i_k);
91 |     admm_iter = 5;
92 |     tolerance = 0.01;
93 |   }
94 | };  // class NTFAOADMM
95 | 
96 | }  // namespace planc
97 | 
98 | #endif  // NTF_NTFAOADMM_HPP_
99 | 


--------------------------------------------------------------------------------
/utilities/partition-uniform.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstdlib>
 3 | #include <vector>
 4 | #include <ctime>
 5 | #include <string>
 6 | #include <iostream>
 7 | #include <cinttypes>
 8 | 
 9 | int main(int argc, char **argv) {
10 |   printf("partition-uniform began.\n");
11 |   if (argc < 4) {
12 |     printf("Usage: partition-uniform [matrix-file-name] [row-proc-count] [col-proc-count]\n");
13 |     return 0;
14 |   }
15 |   int rowProcCount = atoi(argv[2]);
16 |   int colProcCount = atoi(argv[3]);
17 |   int procCount = rowProcCount * colProcCount;
18 |   printf("Creating a %d x %d uniform partition.\n", rowProcCount, colProcCount);
19 | 
20 |   printf("Opening input and output files...\n");
21 |   FILE *file = fopen(argv[1], "r");
22 |   if (file == NULL) {
23 |     printf("Unable to open file %s.\n", argv[1]);
24 |     return 0;
25 |   }
26 | 
27 |   std::vector< std::vector<uint64_t> > procRowIdxs(procCount);
28 |   std::vector< std::vector<uint64_t> > procColIdxs(procCount);
29 |   std::vector< std::vector<double> > procVals(procCount);
30 |   printf("Partitioning nonzeros and outputting to files...\n");
31 |   int order;
32 |   uint64_t nnz;
33 |   uint64_t rowCount, colCount;
34 |   fscanf(file, " %d %" SCNu64, &order, &nnz);
35 |   fscanf(file, "%" SCNu64, &rowCount);
36 |   fscanf(file, "%" SCNu64, &colCount);
37 |   printf("order::%d::nnz::%ju::rowcount::%ju::colcount::%ju\n", order, nnz, rowCount, colCount);
38 |   uint64_t rowsPerProc = rowCount / rowProcCount;
39 |   uint64_t colsPerProc = colCount / colProcCount;
40 |   printf("Assigning %ju rows and %ju columns per part.\n", rowsPerProc, colsPerProc);
41 |   for (uint64_t i = 0; i < nnz; i++) {
42 |     if (i % 100000 == 0 && i > 0) { printf("Processing %ju.th nonzero...\n", i); }
43 |     uint64_t rowIdx, colIdx;
44 |     double val;
45 |     fscanf(file, "%" SCNu64, &rowIdx);
46 |     fscanf(file, "%" SCNu64, &colIdx);
47 |     fscanf(file, "%lf", &val);
48 |     rowIdx--; colIdx--;
49 |     uint64_t procRowIdx = rowIdx / rowsPerProc;
50 |     uint64_t procColIdx = colIdx / colsPerProc;
51 |     if (procRowIdx >= rowProcCount || procColIdx >= colProcCount) { continue; } // Prune matrix
52 |     uint64_t procIdx = procRowIdx * colProcCount + procColIdx;
53 |     uint64_t localRowIdx = rowIdx % rowsPerProc;
54 |     uint64_t localColIdx = colIdx % colsPerProc;
55 |     procRowIdxs[procIdx].push_back(localRowIdx);
56 |     procColIdxs[procIdx].push_back(localColIdx);
57 |     procVals[procIdx].push_back(val);
58 |   }
59 |   fclose(file);
60 | 
61 |   for (int i = 0; i < procCount; i++) {
62 |     int row_rank, col_rank;
63 |     printf("Writing the matrix for part %d...\n", i);
64 |     // zero indexed and row major ordering of pr and pc.
65 |     row_rank = i / colProcCount;
66 |     col_rank = i - row_rank * colProcCount;
67 |     std::string outFileName(argv[1]);
68 |     outFileName += std::to_string(row_rank);
69 |     outFileName += '_';
70 |     outFileName += std::to_string(col_rank);
71 |     file = fopen(outFileName.c_str(), "w");
72 |     if (file == NULL) {
73 |       printf("Unable to open file %s.\n", outFileName.c_str());
74 |       return 0;
75 |     }
76 |     auto &curRowIdxs = procRowIdxs[i];
77 |     auto &curColIdxs = procColIdxs[i];
78 |     auto &curVals = procVals[i];
79 |     for (uint64_t j = 0; j < curRowIdxs.size(); j++) {
80 |       fprintf(file, "%" PRIu64 " %" PRIu64 " %e\n", curRowIdxs[j], curColIdxs[j], curVals[j]);
81 |     }
82 |     fclose(file);
83 |   }
84 | 
85 |   printf("partition-uniform finished.\n");
86 |   return 0;
87 | }
88 | 
89 | 


--------------------------------------------------------------------------------
/hiernmf/README.md:
--------------------------------------------------------------------------------
 1 | # MPI Based HierNMF2
 2 | 
 3 | ## Install Instructions
 4 | 
 5 | This program depends on:
 6 | 
 7 | - [Armadillo](https://arma.sourceforge.net) library for linear algebra operations.
 8 | - [OpenBLAS](https://github.com/xianyi/OpenBLAS) for optimized kernels. If building with OpenBLAS and MKL is discoverable by `cmake`, use `-DCMAKE_IGNORE_MKL=1` while building. 
 9 | 
10 | Once the above steps are completed, set the following environment variables.
11 | 
12 | ````
13 | export ARMADILLO_INCLUDE_DIR=/home/rnu/libraries/armadillo-6.600.5/include/
14 | export LIB=$LIB:/home/rnu/libraries/openblas/lib:
15 | export INCLUDE=$INCLUDE:/home/rnu/libraries/openblas/include:$ARMADILLO_INCLUDE_DIR:
16 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/rnu/libraries/openblas/lib/:
17 | export NMFLIB_DIR=/ccs/home/ramki/rhea/research/nmflib/
18 | export INCLUDE=$INCLUDE:$ARMADILLO_INCLUDE_DIR:$NMFLIB_DIR
19 | export CPATH=$CPATH:$INCLUDE:
20 | export MKLROOT=/ccs/compilers/intel/rh6-x86_64/16.0.0/mkl/
21 | ````
22 | If you have got MKL, please source `mklvars.sh` before running `make`/`cmake`
23 | 
24 | * Create a build directory. 
25 | * Change to the build directory 
26 | * In case of MKL, `source` the ````$MKLROOT/bin/mkl_vars.sh intel64````
27 | * run `cmake` [PATH TO THE CMakeList.txt]. 
28 | * `make`
29 | 
30 | Refer to the build scripts found in the [build](build/README.md) directory for a sample script.
31 | 
32 | ### Input types
33 | PLANC supports both dense and sparse input matrices via the `-DCMAKE_BUILD_SPARSE` flag. To generate a sparse build run the following command.
34 | ```
35 | cmake -DCMAKE_BUILD_SPARSE=1 [path to the CMakeLists.txt]
36 | ``` 
37 | ### Other Macros
38 | 
39 | `cmake` macros
40 | 1. `-DCMAKE_BUILD_SPARSE`: For handling sparse input matrices. Default is a dense build.
41 | 2. `-DCMAKE_BUILD_TYPE=Debug`: For creating debug builds.
42 | 3. `-DCMAKE_WITH_BARRIER_TIMING`: Default is set to barrier timing. To disable build with `-DCMAKE_WITH_BARRIER_TIMING:BOOL=OFF`.
43 | 4. `-DCMAKE_BUILD_CUDA`: Default is off.
44 | 5. `-DCMAKE_IGNORE_MKL`: Ignores MKL when discoverable by `cmake`. If using OpenBLAS, set `-DCMAKE_IGNORE_MKL=1` while building.
45 | 
46 | Code level macros - Defined in distutils.h
47 | 1. `MPI_VERBOSE` - Be **doubly sure** about what you do. It prints all intermediary matrices. Try this only for very very small matrix that is of size less than 10.
48 | 2. `WRITE_RAND_INPUT` - for dumping the generated random matrix.
49 | 
50 | ### IO options
51 | 
52 | PLANC uses MPI-IO to read in dense input matrices.
53 | For sparse matrices, it can reads in files split by the [partitioners](utilities/) provided. 
54 | 
55 | PLANC uses MPI-IO for outputting the factor matrices into a single file per factor matrix.
56 | 
57 | ## Command Line options
58 | For a full list of command line options please run `hiernmf -h`. Some common options are listed below.
59 | * `-p` Sets the processor grid dimensions.
60 | * `-k` Sets the low-rank parameter for the approximation which is the number of leaf nodes in a H2NMF tree.
61 | * `-d` Sets the input dimensions.
62 | * `-e` Switch to toggle error calculation. Off by default.
63 | * `-t` Maximum number of iterations to run the algorithms for.
64 | * `-a` Algorithm to run.
65 | * `-i` Input matrix to run on. Can be a synthetic input via options `rand_lowrank`/`rand_uniform`/`rand_normal` or a path to a file.
66 | * `--nodes` Sets the number of nodes to compute in a H2NMF tree.
67 | 
68 | ## Citation
69 | 
70 | Please refer to the [papers](papers.md) section for the appropriate reports to cite.
71 | 


--------------------------------------------------------------------------------
/common/cmake_aux/NMFLIB_FindARMA.cmake:
--------------------------------------------------------------------------------
  1 | # Copyright 2016 Ramakrishnan Kannan
  2 | # Find Armadillo, BLAS and LAPACK. 
  3 | 
  4 | find_path(ARMADILLO_INCLUDE_DIR
  5 |   NAMES armadillo
  6 |   PATHS "$ENV{ProgramFiles}/Armadillo/include"
  7 |   )
  8 | 
  9 | message(STATUS "     ARMA_FOUND = ${ARMADILLO_INCLUDE_DIR}")
 10 | 
 11 | set(NMFLIB_USE_LAPACK           false)
 12 | set(NMFLIB_USE_BLAS             false)
 13 | set(NMFLIB_USE_ATLAS            false)
 14 | 
 15 | OPTION(CMAKE_IGNORE_MKL "Build Ignoring MKL" ON)
 16 | 
 17 | #to build sparse comment or uncomment this line.
 18 | OPTION(CMAKE_BUILD_SPARSE "Build Sparse" OFF)
 19 | if(CMAKE_BUILD_SPARSE)
 20 |   add_definitions(-DBUILD_SPARSE=1)
 21 | endif()
 22 | 
 23 | OPTION(CMAKE_WITH_BARRIER_TIMING "Barrier placed to collect time" ON)
 24 | if(CMAKE_WITH_BARRIER_TIMING)
 25 |   add_definitions(-D__WITH__BARRIER__TIMING__=1)
 26 | endif()
 27 | 
 28 | #C++11 standard
 29 | set (CMAKE_CXX_STANDARD 11)
 30 | set(CMAKE_CXX_STANDARD_REQUIRED ON)
 31 | #set (CMAKE_CXX_EXTENSIONS OFF) # use -std=c++11 instead of -std=gnu++11
 32 | 
 33 | #while exception get the stack trace
 34 | set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -rdynamic -g3 -O0 ")
 35 | 
 36 | set(CMAKE_MODULE_PATH ${ARMADILLO_INCLUDE_DIR}/../cmake_aux/Modules/)
 37 | message(STATUS "CMAKE_MODULE_PATH = ${CMAKE_MODULE_PATH}" )
 38 | 
 39 | include(CheckIncludeFileCXX)
 40 | include(CheckLibraryExists)
 41 | 
 42 | ##
 43 | ## Find LAPACK and BLAS libraries, or their optimised versions
 44 | ##
 45 | 
 46 | set(NMFLIB_OS unix)
 47 | set(ARMADILLO_INCLUDE_DIRS ${ARMADILLO_INCLUDE_DIR}/../)
 48 | set(ARMADILLO_LIBRARY_DIRS ${ARMADILLO_INCLUDE_DIR}/../)
 49 | 
 50 | # for cray wrapper required is failing
 51 | find_package(BLAS)
 52 | find_package(LAPACK)
 53 | 
 54 | message(STATUS "    BLAS_FOUND = ${BLAS_FOUND}"    )
 55 | message(STATUS "  LAPACK_FOUND = ${LAPACK_FOUND}"  )
 56 | 
 57 | set(NMFLIB_USE_BLAS true)
 58 | set(NMFLIB_USE_LAPACK true)
 59 | if(BLAS_FOUND)
 60 |   set(NMFLIB_LIBS ${NMFLIB_LIBS} ${BLAS_LIBRARIES})
 61 | endif()
 62 | if(LAPACK_FOUND)
 63 |   set(NMFLIB_LIBS ${NMFLIB_LIBS} ${LAPACK_LIBRARIES})
 64 | endif()
 65 | 
 66 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")
 67 | 
 68 | #if(DEFINED CMAKE_CXX_COMPILER_ID AND DEFINED CMAKE_CXX_COMPILER_VERSION)
 69 | #  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT ${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 4.8.3)
 70 | #    set(NMFLIB_USE_EXTERN_CXX11_RNG true)
 71 | #    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 72 | #    message(STATUS "Detected gcc 4.8.3 or later. Added '-std=c++11' to compiler flags")
 73 | #  endif()
 74 | #endif()
 75 | 
 76 | #OPTION(CMAKE_BUILD_CUDA "Build with CUDA/NVBLAS" OFF)
 77 | if(CMAKE_BUILD_CUDA)
 78 |   find_package(CUDA REQUIRED)
 79 | else()
 80 |   find_package(CUDA)
 81 | endif()
 82 | message(STATUS " CUDA_FOUND = ${CUDA_FOUND}" )
 83 | if (CUDA_FOUND)
 84 |   add_definitions(-DBUILD_CUDA=1)
 85 |   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp") 
 86 |   set(NMFLIB_LIBS ${CUDA_LIBRARIES} ${NMFLIB_LIBS})
 87 |   set(NMFLIB_LIBS ${CUDA_CUBLAS_LIBRARIES} ${NMFLIB_LIBS})
 88 |   find_library(CUDA_NVBLAS_LIBRARY 
 89 |                 NAMES nvblas
 90 |                 PATHS ${CUDA_TOOLKIT_ROOT_DIR}
 91 |                 PATH_SUFFIXES lib64
 92 |                 NO_DEFAULT_PATH)
 93 |   set(NMFLIB_LIBS ${CUDA_NVBLAS_LIBRARY} ${NMFLIB_LIBS})
 94 |   include_directories(${CUDA_INCLUDE_DIRS})
 95 | endif()
 96 | #endif()
 97 | 
 98 | set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g3 -O0" CACHE STRING "CXX_DFLAGS_DEBUG" FORCE )
 99 | set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3" CACHE STRING "CXX_FLAGS_RELEASE" FORCE )
100 | set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-as-needed")


--------------------------------------------------------------------------------
/distjointnmf/README.md:
--------------------------------------------------------------------------------
 1 | # MPI Based DistJointNMF
 2 | 
 3 | ## Install Instructions
 4 | 
 5 | This program depends on:
 6 | 
 7 | - Download Armadillo library which can be found at https://arma.sourceforge.net
 8 | - Download and build OpenBLAS https://github.com/xianyi/OpenBLAS
 9 | 
10 | Once the above steps are completed, set the following environment variables.
11 | 
12 | ````
13 | export ARMADILLO_INCLUDE_DIR=/home/rnu/libraries/armadillo-6.600.5/include/
14 | export LIB=$LIB:/home/rnu/libraries/openblas/lib:
15 | export INCLUDE=$INCLUDE:/home/rnu/libraries/openblas/include:$ARMADILLO_INCLUDE_DIR:
16 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/rnu/libraries/openblas/lib/:
17 | export NMFLIB_DIR=/ccs/home/ramki/rhea/research/nmflib/
18 | export INCLUDE=$INCLUDE:$ARMADILLO_INCLUDE_DIR:$NMFLIB_DIR
19 | export CPATH=$CPATH:$INCLUDE:
20 | export MKLROOT=/ccs/compilers/intel/rh6-x86_64/16.0.0/mkl/
21 | ````
22 | 
23 | If you have got MKL, please source MKLVARS.sh before running make/cmake
24 | 
25 | ### Sparse NMF
26 | 
27 | Run cmake with -DCMAKE_BUILD_SPARSE
28 | 
29 | ### Sparse Debug build
30 | 
31 | Run cmake with -DCMAKE_BUILD_SPARSE -DCMAKE_BUILD_TYPE=Debug
32 | 
33 | ### Building on Cray-EOS/Titan
34 | 
35 | CC=CC CXX=CC cmake ~/nmflibrary/distnmf/ -DCMAKE_IGNORE_MKL=1
36 | 
37 | ### Building on Titan with NVBLAS
38 | 
39 | We are using NVBLAS to offload computations to GPU.
40 | By default we enable building with cuda in Titan.
41 | The sample configurations files for nvblas can be found at conf/nvblas_cuda75.conf
42 | and conf/nvblas_cuda91.conf for CUDA Toolkit 7.5 and 9.1 respectively.
43 | 
44 | CC=CC CXX=CC cmake ~/nmflibrary/distnmf/ -DCMAKE_IGNORE_MKL=1 -DCMAKE_BUILD_CUDA=1
45 | 
46 | - Module swap PrgEnv-pgi PrgEnv-gnu
47 | - Module load cmake3
48 | - Module load cudatoolkit
49 | - mkdir /lustre/atlas/world-shared/csc209/ramki/titan/planc-build
50 | - CC=CC CXX=CC cmake ~/planc-github/ -DCMAKE_INSTALL_PREFIX=/lustre/atlas/world-shared/csc209/ramki/titan/planc/
51 | - Make
52 | - Make install
53 | - Cd /lustre/atlas/world-shared/csc209/ramki/titan/planc/bin
54 | - Copied planc-github/conf/nvblas91.conf nvblas.conf
55 | - ldd dense_disntf to get the libsci_gnu_mp_61.so.5 path and set the NVBLAS_CPU_BLAS_LIB
56 | - Run the experiment
57 | 
58 | ### Other Macros
59 | 
60 | * CMAKE macros
61 | 
62 |   For sparse NMF - cmake -DBUILD_SPARSE=1 - Default dense build
63 |   For timing with barrier after mpi calls - cmake -DCMAKE_WITH_BARRIER_TIMING - Default with barrier timing
64 |   For performance, disable the WITH__BARRIER__TIMING. Run as "cmake -DCMAKE_WITH_BARRIER_TIMING:BOOL=OFF"
65 |   For building cuda - -DCMAKE_BUILD_CUDA=1 - Default is off.
66 | 
67 | * Code level macros - Defined in distutils.h
68 | 
69 |   MPI_VERBOSE - Be doubly sure about what you do. It prints all intermediary matrices.
70 | 			   Try this only for very very small matrix that is of size less than 10.
71 |   WRITE_RAND_INPUT - for dumping the generated random matrix
72 | 
73 | ## Output interpretation
74 | 
75 | For W matrix row major ordering. That is., W_0, W_1, .., W_p
76 | For H matrix column major ordering. That is., for 6 processes
77 | with pr=3, pc=2, interpret as H_0, H_2, H_4, H_1, H_3, H_5
78 | 
79 | ## Running
80 | 
81 | mpirun -np 16 ./distnmf -a [0/1/2/3] -i rand_[lowrank/uniform] -d "rows cols" -p "pr pc" -r "W_l2 W_l1 H_l2 H_l0" -k 20 -t 20 -e 1
82 | 
83 | ## Citation:
84 | 
85 | 
86 | If you are using this MPI implementation, kindly cite.
87 | 
88 | Ramakrishnan Kannan, Grey Ballard, and Haesun Park. 2016. A high-performance parallel algorithm for nonnegative matrix factorization. In Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP '16). ACM, New York, NY, USA, , Article 9 , 11 pages. DOI: http://dx.doi.org/10.1145/2851141.2851152
89 | 


--------------------------------------------------------------------------------
/distnmf/README.md:
--------------------------------------------------------------------------------
 1 | # MPI Based DistNMF and DistNTF 
 2 | 
 3 | ## Install Instructions
 4 | 
 5 | This program depends on:
 6 | 
 7 | - Download Armadillo library which can be found at https://arma.sourceforge.net
 8 | - Download and build OpenBLAS https://github.com/xianyi/OpenBLAS
 9 | 
10 | Once the above steps are completed, set the following environment variables.
11 | 
12 | ````
13 | export ARMADILLO_INCLUDE_DIR=/home/rnu/libraries/armadillo-6.600.5/include/
14 | export LIB=$LIB:/home/rnu/libraries/openblas/lib:
15 | export INCLUDE=$INCLUDE:/home/rnu/libraries/openblas/include:$ARMADILLO_INCLUDE_DIR:
16 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/rnu/libraries/openblas/lib/:
17 | export NMFLIB_DIR=/ccs/home/ramki/rhea/research/nmflib/
18 | export INCLUDE=$INCLUDE:$ARMADILLO_INCLUDE_DIR:$NMFLIB_DIR
19 | export CPATH=$CPATH:$INCLUDE:
20 | export MKLROOT=/ccs/compilers/intel/rh6-x86_64/16.0.0/mkl/
21 | ````
22 | 
23 | If you have got MKL, please source MKLVARS.sh before running make/cmake
24 | 
25 | ### Sparse NMF
26 | 
27 | Run cmake with -DCMAKE_BUILD_SPARSE
28 | 
29 | ### Sparse Debug build
30 | 
31 | Run cmake with -DCMAKE_BUILD_SPARSE -DCMAKE_BUILD_TYPE=Debug
32 | 
33 | ### Building on Cray-EOS/Titan
34 | 
35 | CC=CC CXX=CC cmake ~/nmflibrary/distnmf/ -DCMAKE_IGNORE_MKL=1
36 | 
37 | ### Building on Titan with NVBLAS
38 | 
39 | We are using NVBLAS to offload computations to GPU.
40 | By default we enable building with cuda in Titan.
41 | The sample configurations files for nvblas can be found at conf/nvblas_cuda75.conf
42 | and conf/nvblas_cuda91.conf for CUDA Toolkit 7.5 and 9.1 respectively.
43 | 
44 | CC=CC CXX=CC cmake ~/nmflibrary/distnmf/ -DCMAKE_IGNORE_MKL=1 -DCMAKE_BUILD_CUDA=1
45 | 
46 | - Module swap PrgEnv-pgi PrgEnv-gnu
47 | - Module load cmake3
48 | - Module load cudatoolkit
49 | - mkdir /lustre/atlas/world-shared/csc209/ramki/titan/planc-build
50 | - CC=CC CXX=CC cmake ~/planc-github/ -DCMAKE_INSTALL_PREFIX=/lustre/atlas/world-shared/csc209/ramki/titan/planc/
51 | - Make
52 | - Make install
53 | - Cd /lustre/atlas/world-shared/csc209/ramki/titan/planc/bin
54 | - Copied planc-github/conf/nvblas91.conf nvblas.conf
55 | - ldd dense_disntf to get the libsci_gnu_mp_61.so.5 path and set the NVBLAS_CPU_BLAS_LIB
56 | - Run the experiment
57 | 
58 | ### Other Macros
59 | 
60 | * CMAKE macros
61 | 
62 |   For sparse NMF - cmake -DBUILD_SPARSE=1 - Default dense build
63 |   For timing with barrier after mpi calls - cmake -DCMAKE_WITH_BARRIER_TIMING - Default with barrier timing
64 |   For performance, disable the WITH__BARRIER__TIMING. Run as "cmake -DCMAKE_WITH_BARRIER_TIMING:BOOL=OFF"
65 |   For building cuda - -DCMAKE_BUILD_CUDA=1 - Default is off.
66 | 
67 | * Code level macros - Defined in distutils.h
68 | 
69 |   MPI_VERBOSE - Be doubly sure about what you do. It prints all intermediary matrices.
70 | 			   Try this only for very very small matrix that is of size less than 10.
71 |   WRITE_RAND_INPUT - for dumping the generated random matrix
72 | 
73 | ## Output interpretation
74 | 
75 | For W matrix row major ordering. That is., W_0, W_1, .., W_p
76 | For H matrix column major ordering. That is., for 6 processes
77 | with pr=3, pc=2, interpret as H_0, H_2, H_4, H_1, H_3, H_5
78 | 
79 | ## Running
80 | 
81 | mpirun -np 16 ./distnmf -a [0/1/2/3] -i rand_[lowrank/uniform] -d "rows cols" -p "pr pc" -r "W_l2 W_l1 H_l2 H_l0" -k 20 -t 20 -e 1
82 | 
83 | ## Citation:
84 | 
85 | 
86 | If you are using this MPI implementation, kindly cite.
87 | 
88 | Ramakrishnan Kannan, Grey Ballard, and Haesun Park. 2016. A high-performance parallel algorithm for nonnegative matrix factorization. In Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP '16). ACM, New York, NY, USA, , Article 9 , 11 pages. DOI: http://dx.doi.org/10.1145/2851141.2851152
89 | 


--------------------------------------------------------------------------------
/common/npyio.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2018 Ramakrishnan Kannan */
  2 | #ifndef COMMON_NPYIO_HPP_
  3 | #define COMMON_NPYIO_HPP_
  4 | #include <armadillo>
  5 | #include <cassert>
  6 | #include <cstdio>
  7 | #include <string>
  8 | #include <vector>
  9 | #include "common/tensor.hpp"
 10 | #include "common/utils.h"
 11 | 
 12 | namespace planc {
 13 | class NumPyArray {
 14 |  private:
 15 |   int64_t m_word_size;
 16 |   bool m_fortran_order;
 17 |   int64_t m_modes;
 18 |   UVEC m_dims;
 19 |   void parse_npy_header(FILE* fp) {
 20 |     char buffer[256];
 21 |     int64_t res = fread(buffer, sizeof(char), 11, fp);
 22 |     if (res != 11) {
 23 |       ERR << "Something wrong. Could not read header " << std::endl;
 24 |       exit(-1);
 25 |     }
 26 |     buffer[11] = 0;
 27 |     std::cout << "first 11 characters::" << buffer << std::endl;
 28 | 
 29 |     std::string header = fgets(buffer, 256, fp);
 30 |     assert(header[header.size() - 1] == '\n');
 31 | 
 32 |     // fortran order is column major order
 33 |     // C order is row major order
 34 |     int64_t loc1 = header.find("fortran_order");
 35 |     loc1 += 16;
 36 |     this->m_fortran_order = (header.substr(loc1, 4) == "True" ? true : false);
 37 | 
 38 |     // obtain dimensions
 39 |     loc1 = header.find("(");
 40 |     int64_t loc2 = header.find(")");
 41 |     if (loc1 < 0 || loc2 < 0) {
 42 |       ERR << "could not find ()" << std::endl;
 43 |       exit(-1);
 44 |     }
 45 | 
 46 |     std::string str_shape = header.substr(loc1 + 1, loc2 - loc1 - 1);
 47 |     if (str_shape[str_shape.size() - 1] == ',') {
 48 |       this->m_modes = 1;
 49 |     } else {
 50 |       this->m_modes = std::count(str_shape.begin(), str_shape.end(), ',') + 1;
 51 |     }
 52 |     this->m_dims = arma::zeros<UVEC>(m_modes);
 53 | 
 54 |     std::stringstream ss(str_shape);
 55 |     std::string s;
 56 |     ss.str(str_shape);
 57 |     int64_t i = 0;
 58 |     while (getline(ss, s, ',')) {
 59 |       this->m_dims[i++] = ::atoi(s.c_str());
 60 |     }
 61 |     // endian, word size, data type
 62 |     // byte order code | stands for not applicable.
 63 |     // not sure when this applies except for byte array
 64 |     loc1 = header.find("descr");
 65 |     loc1 += 9;
 66 |     bool littleEndian =
 67 |         (header[loc1] == '<' || header[loc1] == '|' ? true : false);
 68 |     assert(littleEndian);
 69 | 
 70 |     std::string word_size = header.substr(loc1 + 2);
 71 |     loc2 = word_size.find("'");
 72 |     this->m_word_size = atoi(word_size.substr(0, loc2).c_str());
 73 |   }
 74 | 
 75 |  public:
 76 |   Tensor* m_input_tensor;
 77 |   NumPyArray() {
 78 |     this->m_word_size = 0;
 79 |     this->m_fortran_order = false;
 80 |     this->m_modes = 0;
 81 |   }
 82 |   void load(std::string fname) {
 83 |     FILE* fp = fopen(fname.c_str(), "rb");
 84 |     if (fp == NULL) {
 85 |       ERR << "Could not load the file " << fname << std::endl;
 86 |       exit(-1);
 87 |     }
 88 |     parse_npy_header(fp);
 89 |     this->m_input_tensor = new Tensor(this->m_dims);
 90 |     int64_t nread = fread(&m_input_tensor->m_data[0],
 91 |                           sizeof(std::vector<double>::value_type),
 92 |                           m_input_tensor->numel(), fp);
 93 |     if (nread != m_input_tensor->numel()) {
 94 |       WARN << "something wrong ::read::" << nread
 95 |            << "::numel::" << this->m_input_tensor->numel()
 96 |            << "::word_size::" << this->m_word_size << std::endl;
 97 |     }
 98 |   }
 99 |   void printInfo() {
100 |     INFO << "modes::" << this->m_modes << "::dims::" << std::endl
101 |          << this->m_dims << "::fortran_order::" << this->m_fortran_order
102 |          << "::word_size::" << this->m_word_size << std::endl;
103 |   }
104 | };
105 | }  // namespace planc
106 | 
107 | #endif  // COMMON_NPYIO_HPP_
108 | 


--------------------------------------------------------------------------------
/hiernmf/matutils.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2020 Lawton Manning */
  2 | #ifndef HIERNMF_MATUTILS_HPP_
  3 | #define HIERNMF_MATUTILS_HPP_
  4 | 
  5 | #include <algorithm>
  6 | #include "common/distutils.hpp"
  7 | #include "common/utils.hpp"
  8 | 
  9 | namespace planc {
 10 | template <class INPUTMATTYPE>
 11 | void print(INPUTMATTYPE M, const char* name) {
 12 |   int size, rank;
 13 |   MPI_Comm_size(MPI_COMM_WORLD, &size);
 14 |   MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 15 | 
 16 |   MPI_Barrier(MPI_COMM_WORLD);
 17 |   if (rank == 0) {
 18 |     M.print(name);
 19 |   }
 20 |   MPI_Barrier(MPI_COMM_WORLD);
 21 |   for (int i = 1; i < size; i++) {
 22 |     if (i == rank) {
 23 |       M.print();
 24 |     }
 25 |     MPI_Barrier(MPI_COMM_WORLD);
 26 |   }
 27 | }
 28 | 
 29 | struct PowerTimings {
 30 |   double communication = 0;
 31 |   double matvec = 0;
 32 |   double vecmat = 0;
 33 |   double normalisation = 0;
 34 | };
 35 | 
 36 | template <class INPUTMATTYPE>
 37 | double powIter(const INPUTMATTYPE& A, int max_iter, double tol,
 38 |                PowerTimings * timings) {
 39 |   // MPI variables
 40 |   int size, rank;
 41 |   MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 42 |   MPI_Comm_size(MPI_COMM_WORLD, &size);
 43 | 
 44 |   // Matrix/Vector sizes
 45 |   int local_m = A.n_rows;
 46 |   int global_n = A.n_cols;
 47 |   int local_n = itersplit(global_n, size, rank);
 48 | 
 49 |   // MPI Comm init
 50 |   int * counts = new int[size];
 51 |   for (int i = 0; i < size; i++) {
 52 |     counts[i] = itersplit(global_n, size, i);
 53 |   }
 54 |   int * displs = new int[size];
 55 |   displs[0] = 0;
 56 |   for (int i = 1; i < size; i++) {
 57 |     displs[i] = displs[i - 1] + counts[i - 1];
 58 |   }
 59 | 
 60 |   // Vector initialization
 61 |   VEC localQ(local_n, arma::fill::randn);
 62 |   VEC globalQ(global_n, arma::fill::zeros);
 63 |   MPITIC;
 64 |   MPI_Allgatherv(localQ.memptr(), local_n, MPI_DOUBLE, globalQ.memptr(), counts,
 65 |                  displs, MPI_DOUBLE, MPI_COMM_WORLD);
 66 |   timings->communication += MPITOC;
 67 |   MPITIC;
 68 |   globalQ /= norm(globalQ);
 69 |   timings->normalisation += MPITOC;
 70 | 
 71 |   // local variables
 72 |   VEC z(local_m);
 73 |   double sigma = 1;
 74 |   double s2 = sigma;
 75 |   double epsilon;
 76 |   double norm;
 77 | 
 78 |   // converge to first sigma value of AtA
 79 |   for (int i = 0; i < max_iter; i++) {
 80 |     MPITIC;
 81 |     z = A * globalQ;
 82 |     timings->matvec += MPITOC;
 83 |     MPITIC;
 84 |     globalQ = A.t() * z;
 85 |     timings->vecmat += MPITOC;
 86 | 
 87 |     // Reduce-Scatter q
 88 |     MPITIC;
 89 |     MPI_Reduce_scatter(globalQ.memptr(), localQ.memptr(), counts, MPI_DOUBLE,
 90 |                        MPI_SUM, MPI_COMM_WORLD);
 91 |     timings->communication += MPITOC;
 92 | 
 93 |     // Normalize q by sigma
 94 |     MPITIC;
 95 |     norm = pow(arma::norm(localQ), 2);
 96 |     MPI_Allreduce(&norm, &sigma, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
 97 |     sigma = sqrt(sigma);
 98 | 
 99 |     localQ /= sigma;
100 |     timings->normalisation += MPITOC;
101 | 
102 |     // All-Gather normalized q
103 |     MPITIC;
104 |     MPI_Allgatherv(localQ.memptr(), local_n, MPI_DOUBLE, globalQ.memptr(),
105 |                    counts, displs, MPI_DOUBLE, MPI_COMM_WORLD);
106 |     timings->communication += MPITOC;
107 | 
108 |     // epsilon tolerance
109 |     epsilon = abs(sigma - s2) / (sigma);
110 |     s2 = sigma;
111 | 
112 |     if (epsilon < tol) {
113 |       break;
114 |     }
115 |   }
116 |   delete counts;
117 |   delete displs;
118 | 
119 |   return sigma;
120 | }
121 | 
122 | VEC maxk(VEC X, int k) {
123 |   VEC Xs = arma::sort(X, "descend");
124 |   if (X.n_elem <= k) {
125 |     return Xs;
126 |   }
127 |   return Xs.head(k);
128 | }
129 | 
130 | UVEC maxk_idx(VEC X, int k) {
131 |   UVEC Xi = arma::sort_index(X, "descend");
132 |   if (X.n_elem <= k) {
133 |     return Xi;
134 |   }
135 |   return Xi.head(k);
136 | }
137 | }  // namespace planc
138 | #endif  // HIERNMF_MATUTILS_HPP_
139 | 


--------------------------------------------------------------------------------
/distnmf/disthals.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 Ramakrishnan Kannan */
  2 | 
  3 | #ifndef DISTNMF_DISTHALS_HPP_
  4 | #define DISTNMF_DISTHALS_HPP_
  5 | 
  6 | #include "distnmf/aunmf.hpp"
  7 | /**
  8 |  * emulating Jingu's code
  9 |  * https://github.com/kimjingu/nonnegfac-matlab/blob/master/nmf.m
 10 |  * function hals_iterSolver
 11 |  */
 12 | 
 13 | namespace planc {
 14 | 
 15 | template <class INPUTMATTYPE>
 16 | class DistHALS : public DistAUNMF<INPUTMATTYPE> {
 17 |  protected:
 18 |   /**
 19 |    * AHtij is of size \f$ k \times \frac{globalm}/{p}\f$.
 20 |    * this->W is of size \f$\frac{globalm}{p} \times k\f$
 21 |    * this->HtH is of size kxk
 22 |    * Eq 14(a) page 7 of JGO paper
 23 |    * \f$W(:,i)=[W(:,i) + (AH(:,i)-WH^TH(:,i))/H^TH(i,i)]_+\f$
 24 |    * column normalize W_i
 25 |    */
 26 |   void updateW() {
 27 |     for (unsigned int i = 0; i < this->k; i++) {
 28 |       // W(:,i) = max(W(:,i) * HHt_reg(i,i) + AHt(:,i) - W *
 29 |       // HHt_reg(:,i),epsilon);
 30 |       VEC updWi = this->W.col(i) * this->HtH(i, i) +
 31 |                   ((this->AHtij.row(i)).t() - this->W * this->HtH.col(i));
 32 | #ifdef MPI_VERBOSE
 33 |       DISTPRINTINFO("b4 fixNumericalError::" << endl << updWi);
 34 | #endif  // ifdef MPI_VERBOSE
 35 |       fixNumericalError<VEC>(&updWi, EPSILON_1EMINUS16, EPSILON_1EMINUS16);
 36 | #ifdef MPI_VERBOSE
 37 |       DISTPRINTINFO("after fixNumericalError::" << endl << updWi);
 38 | #endif  // ifdef MPI_VERBOSE
 39 | 
 40 |       // W(:,i) = W(:,i)/norm(W(:,i));
 41 |       double normWi = arma::norm(updWi, 2);
 42 |       normWi *= normWi;
 43 |       double globalnormWi;
 44 |       mpitic();
 45 |       MPI_Allreduce(&normWi, &globalnormWi, 1, MPI_DOUBLE, MPI_SUM,
 46 |                     MPI_COMM_WORLD);
 47 |       double temp = mpitoc();
 48 |       this->time_stats.communication_duration(temp);
 49 |       this->time_stats.allreduce_duration(temp);
 50 | 
 51 |       if (globalnormWi > 0) {
 52 |         this->W.col(i) = updWi / sqrt(globalnormWi);
 53 |       }
 54 |     }
 55 |     this->Wt = this->W.t();
 56 |   }
 57 | 
 58 |   /**
 59 |    * WtAij is of size \f$k \times \frac{globaln}{p} \f$
 60 |    * this->H is of size \f$ \frac{globaln}{p} \times k\f$
 61 |    * this->WtW is of size kxk
 62 |    * Eq 14(b) page 7 of JGO paper
 63 |    * \f$ H(:,i) = H(:,i) + WtAij(:,i) - HW^TW(:,i)\f$
 64 |    * Here ij is the element of H matrix.
 65 |    */
 66 |   void updateH() {
 67 |     for (unsigned int i = 0; i < this->k; i++) {
 68 |       // H(i,:) = max(H(i,:) + WtA(i,:) - WtW_reg(i,:) * H,epsilon);
 69 |       VEC updHi = this->H.col(i) +
 70 |                   ((this->WtAij.row(i)).t() - this->H * this->WtW.col(i));
 71 | #ifdef MPI_VERBOSE
 72 |       DISTPRINTINFO("b4 fixNumericalError::" << endl << updHi);
 73 | #endif  // ifdef MPI_VERBOSE
 74 |       fixNumericalError<VEC>(&updHi, EPSILON_1EMINUS16, EPSILON_1EMINUS16);
 75 | #ifdef MPI_VERBOSE
 76 |       DISTPRINTINFO("after fixNumericalError::" << endl << updHi);
 77 | #endif  // ifdef MPI_VERBOSE
 78 |       double normHi = arma::norm(updHi, 2);
 79 |       normHi *= normHi;
 80 |       double globalnormHi;
 81 |       mpitic();
 82 |       MPI_Allreduce(&normHi, &globalnormHi, 1, MPI_DOUBLE, MPI_SUM,
 83 |                     MPI_COMM_WORLD);
 84 |       double temp = mpitoc();
 85 |       this->time_stats.communication_duration(temp);
 86 |       this->time_stats.allreduce_duration(temp);
 87 | 
 88 |       if (globalnormHi > 0) {
 89 |         this->H.col(i) = updHi;
 90 |       }
 91 |     }
 92 |     this->Ht = this->H.t();
 93 |   }
 94 | 
 95 |  public:
 96 |   DistHALS(const INPUTMATTYPE& input, const MAT& leftlowrankfactor,
 97 |            const MAT& rightlowrankfactor, const MPICommunicator& communicator,
 98 |            const int numkblks)
 99 |       : DistAUNMF<INPUTMATTYPE>(input, leftlowrankfactor, rightlowrankfactor,
100 |                                 communicator, numkblks) {
101 |     PRINTROOT("DistHALS() constructor successful");
102 |   }
103 | };
104 | 
105 | }  // namespace planc
106 | 
107 | #endif  // DISTNMF_DISTHALS_HPP_
108 | 


--------------------------------------------------------------------------------
/distnmf/distanlsbpp.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 Ramakrishnan Kannan */
  2 | 
  3 | #ifndef DISTNMF_DISTANLSBPP_HPP_
  4 | #define DISTNMF_DISTANLSBPP_HPP_
  5 | 
  6 | #include "distnmf/aunmf.hpp"
  7 | #include "nnls/bppnnls.hpp"
  8 | 
  9 | /**
 10 |  * Provides the updateW and updateH for the
 11 |  * distributed ANLS/BPP algorithm.
 12 |  */
 13 | 
 14 | #ifdef BUILD_CUDA
 15 | #define ONE_THREAD_MATRIX_SIZE 1000
 16 | #include <omp.h>
 17 | #else
 18 | #define ONE_THREAD_MATRIX_SIZE 2000
 19 | #endif
 20 | 
 21 | namespace planc {
 22 | 
 23 | template <class INPUTMATTYPE>
 24 | class DistANLSBPP : public DistAUNMF<INPUTMATTYPE> {
 25 |  private:
 26 |   ROWVEC localWnorm;
 27 |   ROWVEC Wnorm;
 28 | 
 29 |   void allocateMatrices() {}
 30 | 
 31 |   /**
 32 |    * ANLS/BPP with chunking the RHS into smaller independent
 33 |    * subproblems
 34 |    */
 35 |   void updateOtherGivenOneMultipleRHS(const MAT& giventGiven,
 36 |                                       const MAT& giventInput, MAT* othermat) {
 37 |     UINT numChunks = giventInput.n_cols / ONE_THREAD_MATRIX_SIZE;
 38 |     if (numChunks * ONE_THREAD_MATRIX_SIZE < giventInput.n_cols) numChunks++;
 39 | 
 40 | // #pragma omp parallel for schedule(dynamic)
 41 |     for (UINT i = 0; i < numChunks; i++) {
 42 |       UINT spanStart = i * ONE_THREAD_MATRIX_SIZE;
 43 |       UINT spanEnd = (i + 1) * ONE_THREAD_MATRIX_SIZE - 1;
 44 |       if (spanEnd > giventInput.n_cols - 1) {
 45 |         spanEnd = giventInput.n_cols - 1;
 46 |       }
 47 |       BPPNNLS<MAT, VEC> subProblem(giventGiven,
 48 |                             (MAT)giventInput.cols(spanStart, spanEnd), true);
 49 | #ifdef _VERBOSE
 50 |       // #pragma omp critical
 51 |       {
 52 |         INFO << "Scheduling " << worh << " start=" << spanStart
 53 |              << ", end=" << spanEnd
 54 |              // << ", tid=" << omp_get_thread_num()
 55 |              << std::endl
 56 |              << "LHS ::" << std::endl
 57 |              << giventGiven << std::endl
 58 |              << "RHS ::" << std::endl
 59 |              << (MAT)giventInput.cols(spanStart, spanEnd) << std::endl;
 60 |       }
 61 | #endif
 62 | 
 63 |       subProblem.solveNNLS();
 64 | 
 65 | #ifdef _VERBOSE
 66 |       INFO << "completed " << worh << " start=" << spanStart
 67 |            << ", end=" << spanEnd
 68 |            // << ", tid=" << omp_get_thread_num() << " cpu=" << sched_getcpu()
 69 |            << " time taken=" << t2 << std::endl;
 70 | #endif
 71 |       (*othermat).rows(spanStart, spanEnd) = subProblem.getSolutionMatrix().t();
 72 |     }
 73 |   }
 74 | 
 75 |  protected:
 76 |   /**
 77 |    * update W given HtH and AHt
 78 |    * AHtij is of size \f$ k \times \frac{globalm}/{p}\f$.
 79 |    * this->W is of size \f$\frac{globalm}{p} \times k \f$
 80 |    * this->HtH is of size kxk
 81 |   */
 82 |   void updateW() {
 83 |     updateOtherGivenOneMultipleRHS(this->HtH, this->AHtij, &this->W);
 84 |     this->Wt = this->W.t();
 85 |   }
 86 |   /**
 87 |    * updateH given WtAij and WtW
 88 |    * WtAij is of size \f$k \times \frac{globaln}{p} \f$
 89 |    * this->H is of size \f$ \frac{globaln}{p} \times k \f$
 90 |    * this->WtW is of size kxk
 91 |    */  
 92 |   void updateH() {
 93 |     updateOtherGivenOneMultipleRHS(this->WtW, this->WtAij, &this->H);
 94 |     this->Ht = this->H.t();
 95 |   }
 96 | 
 97 |  public:
 98 |   DistANLSBPP(const INPUTMATTYPE& input, const MAT& leftlowrankfactor,
 99 |               const MAT& rightlowrankfactor,
100 |               const MPICommunicator& communicator, const int numkblks)
101 |       : DistAUNMF<INPUTMATTYPE>(input, leftlowrankfactor, rightlowrankfactor,
102 |                                 communicator, numkblks) {
103 |     localWnorm.zeros(this->k);
104 |     Wnorm.zeros(this->k);
105 |     PRINTROOT("DistANLSBPP() constructor successful");
106 |   }
107 | 
108 |   ~DistANLSBPP() {
109 |     /*
110 |        tempHtH.clear();
111 |        tempWtW.clear();
112 |        tempAHtij.clear();
113 |        tempWtAij.clear();
114 |      */
115 |   }
116 | };  // class DistANLSBPP2D
117 | 
118 | }  // namespace planc
119 | 
120 | #endif  // DISTNMF_DISTANLSBPP_HPP_
121 | 


--------------------------------------------------------------------------------
/distnmf/distmu.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 Ramakrishnan Kannan */
  2 | 
  3 | #ifndef DISTNMF_DISTMU_HPP_
  4 | #define DISTNMF_DISTMU_HPP_
  5 | #include "distnmf/aunmf.hpp"
  6 | 
  7 | /**
  8 |  * Distributed MU factorization.
  9 |  * Offers implementation for the pure virtual function
 10 |  * updateW and updateH based on MU.
 11 |  */
 12 | 
 13 | namespace planc {
 14 | 
 15 | template <class INPUTMATTYPE>
 16 | class DistMU : public DistAUNMF<INPUTMATTYPE> {
 17 |   MAT HWtW;
 18 |   MAT WHtH;
 19 |   ROWVEC localWnorm;
 20 |   ROWVEC Wnorm;
 21 | 
 22 |  protected:
 23 |   /**
 24 |    * update W given HtH and AHt
 25 |    * AHtij is of size \f$ k \times \frac{globalm}/{p}\f$.
 26 |    * this->W is of size \f$\frac{globalm}{p} \times k\f$
 27 |    * this->HtH is of size kxk
 28 |    * \f$w_{ij} = w_{ij} .* \frac{(AH)_{ij}}{(WH^TH)_{ij}}\f$
 29 |    * Here ij is the element of W matrix.
 30 |    */
 31 |   void updateW() {
 32 |     WHtH = (this->W * this->HtH) + EPSILON;
 33 | #ifdef MPI_VERBOSE
 34 |     DISTPRINTINFO("::WHtH::" << endl << this->WHtH);
 35 | #endif  // ifdef MPI_VERBOSE
 36 |     this->W = (this->W % this->AHtij.t()) / WHtH;
 37 |     DISTPRINTINFO("MU::updateW::HtH::"
 38 |                   << PRINTMATINFO(this->HtH) << "::WHtH::" << PRINTMATINFO(WHtH)
 39 |                   << "::AHtij::" << PRINTMATINFO(this->AHtij)
 40 |                   << "::W::" << PRINTMATINFO(this->W));
 41 |     DISTPRINTINFO("MU::updateW::HtH::"
 42 |                   << norm(this->HtH, "fro") << "::WHtH::" << norm(WHtH, "fro")
 43 |                   << "::AHtij::" << norm(this->AHtij, "fro")
 44 |                   << "::W::" << norm(this->W, "fro"));
 45 | 
 46 |     /*localWnorm = sum(this->W % this->W);
 47 |        mpitic();
 48 |        MPI_Allreduce(localWnorm.memptr(), Wnorm.memptr(), this->k, MPI_FLOAT,
 49 |                   MPI_SUM, MPI_COMM_WORLD);
 50 |        double temp = mpitoc();
 51 |        this->time_stats.allgather_duration(temp);
 52 |        for (int i = 0; i < this->k; i++) {
 53 |        if (Wnorm(i) > 1) {
 54 |         float norm_const = sqrt(Wnorm(i));
 55 |         this->W.col(i) = this->W.col(i) / norm_const;
 56 |         //this->H.col(i) = norm_const * this->H.col(i);
 57 |        }
 58 |        }*/
 59 |     this->Wt = this->W.t();
 60 |   }
 61 |   /**
 62 |    * updateH given WtAij and WtW
 63 |    * WtAij is of size \f$k \times \frac{globaln}{p} \f$
 64 |    * this->H is of size \f$ \frac{globaln}{p} \times k\f$
 65 |    * this->WtW is of size kxk
 66 |    * \f$h_{ij} = \frac{h_{ij} .* WtAij.t()}{(HW^TW)_{ij}}\f$
 67 |    * Here ij is the element of H matrix.
 68 |    */  
 69 |   void updateH() {
 70 |     HWtW = this->H * this->WtW + EPSILON;
 71 |     this->H = (this->H % this->WtAij.t()) / HWtW;
 72 | #ifdef MPI_VERBOSE
 73 |     DISTPRINTINFO("::HWtW::" << endl << HWtW);
 74 | #endif  // ifdef MPI_VERBOSE
 75 | 
 76 |     // fixNumericalError<MAT>(&this->H);
 77 |     DISTPRINTINFO("MU::updateH::WtW::"
 78 |                   << PRINTMATINFO(this->WtW) << "::HWtW::" << PRINTMATINFO(HWtW)
 79 |                   << "::WtAij::" << PRINTMATINFO(this->WtAij)
 80 |                   << "::H::" << PRINTMATINFO(this->H));
 81 |     DISTPRINTINFO("MU::updateH::WtW::"
 82 |                   << norm(this->WtW, "fro") << "::HWtW::" << norm(HWtW, "fro")
 83 |                   << "::WtAij::" << norm(this->WtAij, "fro")
 84 |                   << "::H::" << norm(this->H, "fro"));
 85 |     this->Ht = this->H.t();
 86 |   }
 87 | 
 88 |  public:
 89 |   DistMU(const INPUTMATTYPE& input, const MAT& leftlowrankfactor,
 90 |          const MAT& rightlowrankfactor, const MPICommunicator& communicator,
 91 |          const int numkblks)
 92 |       : DistAUNMF<INPUTMATTYPE>(input, leftlowrankfactor, rightlowrankfactor,
 93 |                                 communicator, numkblks) {
 94 |     WHtH.zeros(this->globalm() / this->m_mpicomm.size(), this->k);
 95 |     HWtW.zeros(this->globaln() / this->m_mpicomm.size(), this->k);
 96 |     localWnorm.zeros(this->k);
 97 |     Wnorm.zeros(this->k);
 98 |     PRINTROOT("DistMU() constructor successful");
 99 |   }
100 | };
101 | 
102 | }  // namespace planc
103 | 
104 | #endif  // DISTNMF_DISTMU_HPP_
105 | 


--------------------------------------------------------------------------------
/nmf/hals.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 Ramakrishnan Kannan */
  2 | 
  3 | #ifndef NMF_HALS_HPP_
  4 | #define NMF_HALS_HPP_
  5 | 
  6 | #include "common/nmf.hpp"
  7 | 
  8 | namespace planc {
  9 | 
 10 | template <class T>
 11 | class HALSNMF : public NMF<T> {
 12 |  private:
 13 |   // Not happy with this design. However to avoid computing At again and again
 14 |   // making this as private variable.
 15 |   T At;
 16 |   MAT WtW;
 17 |   MAT HtH;
 18 |   MAT WtA;
 19 |   MAT AH;
 20 | 
 21 |   /*
 22 |    * Collected statistics are
 23 |    * iteration Htime Wtime totaltime normH normW densityH densityW relError
 24 |    */
 25 |   void allocateMatrices() {
 26 |     WtW = arma::zeros<MAT>(this->k, this->k);
 27 |     HtH = arma::zeros<MAT>(this->k, this->k);
 28 |     WtA = arma::zeros<MAT>(this->n, this->k);
 29 |     AH = arma::zeros<MAT>(this->m, this->k);
 30 |   }
 31 |   void freeMatrices() {
 32 |     this->At.clear();
 33 |     WtW.clear();
 34 |     HtH.clear();
 35 |     WtA.clear();
 36 |     AH.clear();
 37 |   }
 38 | 
 39 |  public:
 40 |   HALSNMF(const T &A, int lowrank) : NMF<T>(A, lowrank) {
 41 |     this->normalize_by_W();
 42 |     allocateMatrices();
 43 |     this->At = this->A.t();
 44 |   }
 45 |   HALSNMF(const T &A, const MAT &llf, const MAT &rlf) : NMF<T>(A, llf, rlf) {
 46 |     this->normalize_by_W();
 47 |     allocateMatrices();
 48 |     this->At = this->A.t();
 49 |   }
 50 |   void computeNMF() {
 51 |     unsigned int currentIteration = 0;
 52 |     INFO << "computed transpose At=" << PRINTMATINFO(this->At) << std::endl;
 53 |     while (currentIteration < this->num_iterations()) {
 54 |       tic();
 55 |       // update H
 56 |       tic();
 57 |       WtA = this->W.t() * this->A;
 58 |       WtW = this->W.t() * this->W;
 59 |       this->applyReg(this->regH(), &this->WtW);
 60 |       INFO << "starting H Prereq for "
 61 |            << " took=" << toc() << PRINTMATINFO(WtW) << PRINTMATINFO(WtA)
 62 |            << std::endl;
 63 |       // to avoid divide by zero error.
 64 |       tic();
 65 |       double normConst;
 66 |       VEC Hx;
 67 |       for (unsigned int x = 0; x < this->k; x++) {
 68 |         // H(i,:) = max(H(i,:) + WtA(i,:) - WtW_reg(i,:) * H,epsilon);
 69 |         Hx = this->H.col(x) + (((WtA.row(x)).t()) - (this->H * (WtW.col(x))));
 70 |         fixNumericalError<VEC>(&Hx, EPSILON_1EMINUS16, EPSILON_1EMINUS16);
 71 |         normConst = norm(Hx);
 72 |         if (normConst != 0) {
 73 |           this->H.col(x) = Hx;
 74 |         }
 75 |       }
 76 |       INFO << "Completed H (" << currentIteration << "/"
 77 |            << this->num_iterations() << ")"
 78 |            << " time =" << toc() << std::endl;
 79 |       // update W;
 80 |       tic();
 81 |       AH = this->A * this->H;
 82 |       HtH = this->H.t() * this->H;
 83 |       this->applyReg(this->regW(), &this->HtH);
 84 |       INFO << "starting W Prereq for "
 85 |            << " took=" << toc() << PRINTMATINFO(HtH) << PRINTMATINFO(AH)
 86 |            << std::endl;
 87 |       tic();
 88 |       VEC Wx;
 89 |       for (unsigned int x = 0; x < this->k; x++) {
 90 |         // FVEC Wx = W(:,x) + (AHt(:,x)-W*HHt(:,x))/HHtDiag(x);
 91 | 
 92 |         // W(:,i) = max(W(:,i) * HHt_reg(i,i) + AHt(:,i) - W * HHt_reg(:,i),
 93 |         //              epsilon);
 94 |         Wx = (this->W.col(x) * HtH(x, x)) +
 95 |              (((AH.col(x))) - (this->W * (HtH.col(x))));
 96 |         fixNumericalError<VEC>(&Wx, EPSILON_1EMINUS16, EPSILON_1EMINUS16);
 97 |         normConst = norm(Wx);
 98 |         if (normConst != 0) {
 99 |           Wx = Wx / normConst;
100 |           this->W.col(x) = Wx;
101 |         }
102 |       }
103 |       this->normalize_by_W();
104 | 
105 |       INFO << "Completed W (" << currentIteration << "/"
106 |            << this->num_iterations() << ")"
107 |            << " time =" << toc() << std::endl;
108 | 
109 |       INFO << "Completed It (" << currentIteration << "/"
110 |            << this->num_iterations() << ")"
111 |            << " time =" << toc() << std::endl;
112 |       this->computeObjectiveError();
113 |       this->printObjective(currentIteration);
114 |       currentIteration++;
115 |     }
116 |   }
117 |   ~HALSNMF() {}
118 | };
119 | 
120 | }  // namespace planc
121 | 
122 | #endif  // NMF_HALS_HPP_
123 | 


--------------------------------------------------------------------------------
/distnmf/mpicomm.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 Ramakrishnan Kannan */
  2 | 
  3 | #ifndef DISTNMF_MPICOMM_HPP_
  4 | #define DISTNMF_MPICOMM_HPP_
  5 | 
  6 | #include <mpi.h>
  7 | #include <vector>
  8 | #include "common/distutils.hpp"
  9 | 
 10 | #ifdef USE_PACOSS
 11 | #include "pacoss/pacoss.h"
 12 | #endif
 13 | 
 14 | /**
 15 |  * Class and function for 2D MPI communicator
 16 |  * with row and column communicators
 17 |  */
 18 | 
 19 | namespace planc {
 20 | 
 21 | class MPICommunicator {
 22 |  private:
 23 |   int m_rank;  /// Local Rank
 24 |   int m_numProcs;  /// Total number of mpi process
 25 |   int m_row_rank;
 26 |   int m_row_size;
 27 |   int m_col_rank;
 28 |   int m_col_size;
 29 |   int m_pr, m_pc;
 30 |   MPI_Comm m_gridComm;
 31 | 
 32 |   // for 2D communicators
 33 |   // MPI Related stuffs
 34 |   MPI_Comm *m_commSubs;
 35 |   void printConfig() {
 36 |     if (rank() == 0) {
 37 |       INFO << "successfully setup MPI communicators" << std::endl;
 38 |       INFO << "size=" << size() << std::endl;
 39 |       INFO << "rowsize=" << m_row_size << ":pr=" << m_pr << std::endl;
 40 |       INFO << "colsize=" << m_col_size << ":pc=" << m_pc << std::endl;
 41 |     }
 42 |     MPI_Barrier(MPI_COMM_WORLD);
 43 |     INFO << ":rank=" << rank() << ":row_rank=" << row_rank() << ":colrank"
 44 |          << col_rank() << std::endl;
 45 |   }
 46 | 
 47 |  public:
 48 |   // Violating the cpp guidlines. Other functions need
 49 |   // non const pointers.
 50 |   MPICommunicator(int argc, char *argv[]) {
 51 | #ifdef USE_PACOSS
 52 |     TMPI_Init(&argc, &argv);
 53 | #else
 54 |     MPI_Init(&argc, &argv);
 55 | #endif
 56 |     MPI_Comm_rank(MPI_COMM_WORLD, &m_rank);
 57 |     MPI_Comm_size(MPI_COMM_WORLD, &m_numProcs);
 58 |   }
 59 |   ~MPICommunicator() {
 60 |     MPI_Barrier(MPI_COMM_WORLD);
 61 | #ifdef USE_PACOSS
 62 |     TMPI_Finalize();
 63 | #else
 64 |     MPI_Finalize();
 65 | #endif
 66 |   }
 67 |   MPICommunicator(int argc, char *argv[], int pr, int pc) {
 68 | #ifdef USE_PACOSS
 69 |     TMPI_Init(&argc, &argv);
 70 | #else
 71 |     MPI_Init(&argc, &argv);
 72 | #endif
 73 |     MPI_Comm_rank(MPI_COMM_WORLD, &m_rank);
 74 |     MPI_Comm_size(MPI_COMM_WORLD, &m_numProcs);
 75 |     int reorder = 0;
 76 |     std::vector<int> dimSizes;
 77 |     std::vector<int> periods;
 78 |     int nd = 2;
 79 |     dimSizes.resize(nd);
 80 |     this->m_pr = pr;
 81 |     this->m_pc = pc;
 82 |     dimSizes[0] = pr;
 83 |     dimSizes[1] = pc;
 84 |     periods.resize(nd);
 85 |     //MPI_Comm gridComm;
 86 |     std::vector<int> gridCoords;
 87 |     fillVector<int>(1, &periods);
 88 |     // int MPI_Cart_create(MPI_Comm comm_old, int ndims, const int dims[],
 89 |     //                const int periods[], int reorder, MPI_Comm *comm_cart)
 90 |     if (dimSizes[0] * dimSizes[1] != m_numProcs) {
 91 |       if (m_rank == 0) {
 92 |         std::cerr << "Processor grid dimensions do not"
 93 |                   << "multiply to MPI_SIZE::" << dimSizes[0] << 'x'
 94 |                   << dimSizes[1] << "::m_numProcs::" << m_numProcs << std::endl;
 95 |       }
 96 |       MPI_Barrier(MPI_COMM_WORLD);
 97 |       MPI_Abort(MPI_COMM_WORLD, 1);
 98 |     }
 99 |     MPI_Cart_create(MPI_COMM_WORLD, nd, &dimSizes[0], &periods[0], reorder,
100 |                     &m_gridComm);
101 |     gridCoords.resize(nd);
102 |     MPI_Cart_get(m_gridComm, nd, &dimSizes[0], &periods[0], &(gridCoords[0]));
103 |     this->m_commSubs = new MPI_Comm[nd];
104 |     int *keepCols = new int[nd];
105 |     for (int i = 0; i < nd; i++) {
106 |       std::fill_n(keepCols, nd, 0);
107 |       keepCols[i] = 1;
108 |       MPI_Cart_sub(m_gridComm, keepCols, &(this->m_commSubs[i]));
109 |     }
110 |     MPI_Comm_size(m_commSubs[0], &m_row_size);
111 |     MPI_Comm_size(m_commSubs[1], &m_col_size);
112 |     MPI_Comm_rank(m_commSubs[0], &m_row_rank);
113 |     MPI_Comm_rank(m_commSubs[1], &m_col_rank);
114 | #ifdef MPI_VERBOSE
115 |     printConfig();
116 | #endif
117 |   }
118 |   /// returns the global rank
119 |   const int rank() const { return m_rank; }
120 |   /// returns the total number of mpi processes
121 |   const int size() const { return m_numProcs; }
122 |   /// returns its rank in the row processor grid
123 |   const int row_rank() const { return m_row_rank; }
124 |   /// returns the rank in the column processor grid
125 |   const int col_rank() const { return m_col_rank; }
126 |   /// Total number of row processors
127 |   const int pr() const { return m_pr; }
128 |   /// Total number of column processor
129 |   const int pc() const { return m_pc; }
130 |   const MPI_Comm *commSubs() const { return m_commSubs; }
131 |   const MPI_Comm gridComm() const { return m_gridComm; }
132 | };
133 | 
134 | }  // namespace planc
135 | 
136 | #endif  // DISTNMF_MPICOMM_HPP_
137 | 


--------------------------------------------------------------------------------
/common/parsecommandline.h:
--------------------------------------------------------------------------------
  1 | /* Copyright Ramakrishnan Kannan 2017 */
  2 | 
  3 | #ifndef COMMON_PARSECOMMANDLINE_H_
  4 | #define COMMON_PARSECOMMANDLINE_H_
  5 | 
  6 | #include <getopt.h>
  7 | #include "common/utils.h"
  8 | 
  9 | // usage scenarios
 10 | // NMFLibrary algotype lowrank AfileName numIteration
 11 | // NMFLibrary algotype lowrank m n numIteration
 12 | // NMFLibrary algotype lowrank Afile WInitfile HInitfile numIteration
 13 | // NMFLibrary algotype lowrank Afile WInitfile HInitfile WoutputFile HoutputFile
 14 | // numIteration #define WINITFLAG 1000 #define HINITFLAG 1001 #define REGWFLAG
 15 | // 1002 #define REGHFLAG  1003
 16 | 
 17 | // distnmf related defines
 18 | // #define PROCROWS        2002
 19 | // #define PROCCOLS        2003
 20 | #define NUMKBLOCKS 2004
 21 | #define NORMALIZATION 2005
 22 | #define DIMTREE 2006
 23 | #define SYMMETRICREG 2007
 24 | #define ADJRAND 2008
 25 | #define NUMLUCITERS 2009
 26 | #define INITSEED 2010
 27 | #define ALPHAREG 2011
 28 | #define BETAREG 2012
 29 | #define MAT_TYPE 2013
 30 | #define MOMENTUM 2014
 31 | #define UNPARTITIONED 2015
 32 | 
 33 | // enum factorizationtype{FT_NMF, FT_DISTNMF, FT_NTF, FT_DISTNTF};
 34 | 
 35 | // struct option nmfopts[] = {
 36 | //   {"input",       required_argument, 0, 'i'},
 37 | //   {"algo",        required_argument, 0, 'a'},
 38 | //   {"lowrank",     optional_argument, 0, 'k'},
 39 | //   {"iter",        optional_argument, 0, 't'},
 40 | //   {"rows",        optional_argument, 0, 'm'},
 41 | //   {"columns",     optional_argument, 0, 'n'},
 42 | //   {"winit",       optional_argument, 0, WINITFLAG},
 43 | //   {"hinit",       optional_argument, 0, HINITFLAG},
 44 | //   {"wout",        optional_argument, 0, 'w'},
 45 | //   {"hout",        optional_argument, 0, 'h'},
 46 | //   {"regw",        optional_argument, 0, REGWFLAG},
 47 | //   {"regh",        optional_argument, 0, REGHFLAG},
 48 | //   {0,         0,                 0,  0 }
 49 | // };
 50 | 
 51 | // usage scenarios
 52 | // mpirun -np 12 distnmf algotype lowrank AfileName numIteration pr pc
 53 | // mpirun -np 12 distnmf algotype lowrank m n numIteration pr pc
 54 | // mpirun -np 12 distnmf algotype lowrank Afile  outputfile numIteration pr pc
 55 | 
 56 | // we are not supporting initfiles for distnmf.
 57 | // consistent initializations will be distIO
 58 | // struct option distnmfopts[] = {
 59 | //     {"input",       required_argument, 0, 'i'},
 60 | //     {"algo",        required_argument, 0, 'a'},
 61 | //     {"error",       optional_argument, 0, 'e'},
 62 | //     {"lowrank",     required_argument, 0, 'k'},
 63 | //     {"iter",        optional_argument, 0, 't'},
 64 | //     {"rows",        optional_argument, 0, 'm'},
 65 | //     {"columns",     optional_argument, 0, 'n'},
 66 | //     {"output",      optional_argument, 0, 'o'},
 67 | //     {"sparsity",    optional_argument, 0, 's'},
 68 | //     {"pr",          optional_argument, 0, PROCROWS},
 69 | //     {"pc",          optional_argument, 0, PROCCOLS},
 70 | //     {"regw",        optional_argument, 0, REGWFLAG},
 71 | //     {"regh",        optional_argument, 0, REGHFLAG},
 72 | //     {"numkblocks",  optional_argument, 0, NUMKBLOCKS},
 73 | //     {0,             0,                 0,  0 }
 74 | // };
 75 | 
 76 | // usage scenarios
 77 | // mpirun -np 12 distnmf algotype lowrank AfileName numIteration pr pc
 78 | // mpirun -np 12 distnmf algotype lowrank m n numIteration pr pc
 79 | // mpirun -np 12 distnmf algotype lowrank Afile  outputfile numIteration pr pc
 80 | 
 81 | struct option plancopts[] = {
 82 |     {"algo", required_argument, 0, 'a'},
 83 |     {"dimensions", required_argument, 0, 'd'},
 84 |     {"error", required_argument, 0, 'e'},
 85 |     {"input", required_argument, 0, 'i'},
 86 |     {"lowrank", required_argument, 0, 'k'},
 87 |     {"output", required_argument, 0, 'o'},
 88 |     {"processors", required_argument, 0, 'p'},
 89 |     {"regularizer", required_argument, 0, 'r'},
 90 |     {"sparsity", required_argument, 0, 's'},
 91 |     {"iter", required_argument, 0, 't'},
 92 |     {"nodes", required_argument, 0, 'n'},
 93 |     {"tolerance", required_argument, 0, 'l'},
 94 |     {"connection_matrix", required_argument, 0, 'c'},
 95 |     {"numkblocks", required_argument, 0, NUMKBLOCKS},
 96 |     {"normalization", required_argument, 0, NORMALIZATION},
 97 |     {"dimtree", required_argument, 0, DIMTREE},
 98 |     {"symm", required_argument, 0, SYMMETRICREG},
 99 |     {"alpha", required_argument, 0, ALPHAREG},
100 |     {"beta", required_argument, 0, BETAREG},
101 |     {"mat_type", required_argument, 0, MAT_TYPE},
102 |     {"adjrand", no_argument, 0, ADJRAND},
103 |     {"luciters", required_argument, 0, NUMLUCITERS},
104 |     {"seed", required_argument, 0, INITSEED},
105 |     {"conn_grid", required_argument, 0, 'q'},
106 |     {"momentum", required_argument, 0, MOMENTUM},
107 |     {"unpartitioned", required_argument, 0, UNPARTITIONED},
108 |     {0, 0, 0, 0}};
109 | 
110 | #endif  // COMMON_PARSECOMMANDLINE_H_
111 | 
112 | 


--------------------------------------------------------------------------------
/distntf/distntftime.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 Ramakrishnan Kannan */
  2 | 
  3 | #ifndef DISTNTF_DISTNTFTIME_HPP_
  4 | #define DISTNTF_DISTNTFTIME_HPP_
  5 | 
  6 | namespace planc {
  7 | class DistNTFTime {
  8 |  private:
  9 |   double m_duration;
 10 |   double m_compute_duration;
 11 |   double m_communication_duration;
 12 |   double m_allgather_duration;
 13 |   double m_allreduce_duration;
 14 |   double m_reducescatter_duration;
 15 |   double m_gram_duration;
 16 |   double m_krp_duration;
 17 |   double m_mttkrp_duration;
 18 |   double m_multittv_duration;  // needed only for dimtrees
 19 |   double m_nnls_duration;
 20 |   double m_err_compute_duration;
 21 |   double m_err_communication_duration;
 22 |   double m_trans_duration;
 23 | 
 24 |  public:
 25 |   DistNTFTime(double d, double compute_d, double communication_d,
 26 |               double err_comp, double err_comm)
 27 |       : m_duration(d),
 28 |         m_compute_duration(compute_d),
 29 |         m_communication_duration(communication_d),
 30 |         m_err_compute_duration(err_comp),
 31 |         m_err_communication_duration(err_comm) {
 32 |     m_allgather_duration = 0;
 33 |     m_allreduce_duration = 0;
 34 |     m_reducescatter_duration = 0;
 35 |     m_gram_duration = 0;
 36 |     m_krp_duration = 0;
 37 |     m_mttkrp_duration = 0;
 38 |     m_multittv_duration = 0;  // needed only for dimtrees
 39 |     m_nnls_duration = 0;
 40 |     m_trans_duration = 0;
 41 |   }
 42 |   DistNTFTime(double d, double compute_d, double communication_d,
 43 |               double trans_d, double allgather_d, double allreduce_d,
 44 |               double reducescatter_d, double gram_d, double krp_d,
 45 |               double mttkrp_d, double multittv_d, double nnls_d,
 46 |               double err_comp, double err_comm)
 47 |       : m_duration(d),
 48 |         m_compute_duration(compute_d),
 49 |         m_communication_duration(communication_d),
 50 |         m_allgather_duration(allgather_d),
 51 |         m_allreduce_duration(allreduce_d),
 52 |         m_reducescatter_duration(reducescatter_d),
 53 |         m_gram_duration(gram_d),
 54 |         m_krp_duration(krp_d),
 55 |         m_mttkrp_duration(mttkrp_d),
 56 |         m_multittv_duration(multittv_d),
 57 |         m_nnls_duration(nnls_d),
 58 |         m_err_compute_duration(err_comp),
 59 |         m_err_communication_duration(err_comm),
 60 |         m_trans_duration(trans_d) {}
 61 |   DistNTFTime(double d, double compute_d, double communication_d, double gram_d,
 62 |               double krp_d, double mttkrp_d, double multittv_d, double nnls_d,
 63 |               double err_comp, double err_comm)
 64 |       : m_duration(d),
 65 |         m_compute_duration(compute_d),
 66 |         m_communication_duration(communication_d),
 67 |         m_gram_duration(gram_d),
 68 |         m_krp_duration(krp_d),
 69 |         m_mttkrp_duration(mttkrp_d),
 70 |         m_multittv_duration(multittv_d),
 71 |         m_nnls_duration(nnls_d),
 72 |         m_err_compute_duration(err_comp),
 73 |         m_err_communication_duration(err_comm) {}
 74 | 
 75 |   const double duration() const { return m_duration; }
 76 |   const double compute_duration() const { return m_compute_duration; }
 77 |   const double communication_duration() const {
 78 |     return m_communication_duration;
 79 |   }
 80 |   const double allgather_duration() const { return m_allgather_duration; }
 81 |   const double allreduce_duration() const { return m_allreduce_duration; }
 82 |   const double reducescatter_duration() const {
 83 |     return m_reducescatter_duration;
 84 |   }
 85 |   const double gram_duration() const { return m_gram_duration; }
 86 |   const double krp_duration() const { return m_krp_duration; }
 87 |   const double mttkrp_duration() const { return m_mttkrp_duration; }
 88 |   const double multittv_duration() const { return m_multittv_duration; }
 89 |   const double nnls_duration() const { return m_nnls_duration; }
 90 |   const double err_compute_duration() const { return m_err_compute_duration; }
 91 |   const double err_communication_duration() const {
 92 |     return m_err_communication_duration;
 93 |   }
 94 |   const double trans_duration() const { return m_trans_duration; }
 95 |   void duration(double d) { m_duration += d; }
 96 |   void compute_duration(double d) { m_compute_duration += d; }
 97 |   void communication_duration(double d) { m_communication_duration += d; }
 98 |   void allgather_duration(double d) { m_allgather_duration += d; }
 99 |   void allreduce_duration(double d) { m_allreduce_duration += d; }
100 |   void reducescatter_duration(double d) { m_reducescatter_duration += d; }
101 |   void gram_duration(double d) { m_gram_duration += d; }
102 |   void krp_duration(double d) { m_krp_duration += d; }
103 |   void mttkrp_duration(double d) { m_mttkrp_duration += d; }
104 |   void multittv_duration(double d) { m_multittv_duration += d; }
105 |   void nnls_duration(double d) { m_nnls_duration += d; }
106 |   void trans_duration(double d) { m_trans_duration += d; }
107 |   void err_compute_duration(double d) { m_err_compute_duration += d; }
108 |   void err_communication_duration(double d) {
109 |     m_err_communication_duration += d;
110 |   }
111 | };
112 | }  // namespace planc
113 | 
114 | #endif  // DISTNTF_DISTNTFTIME_HPP_
115 | 


--------------------------------------------------------------------------------
/distnmf/distnmf.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 Ramakrishnan Kannan */
  2 | 
  3 | #ifndef DISTNMF_DISTNMF_HPP_
  4 | #define DISTNMF_DISTNMF_HPP_
  5 | 
  6 | #include <string>
  7 | #include "common/nmf.hpp"
  8 | #include "distnmf/mpicomm.hpp"
  9 | #include "distnmftime.hpp"
 10 | #ifdef USE_PACOSS
 11 | #include "pacoss.h"
 12 | #endif
 13 | 
 14 | namespace planc {
 15 | template <typename INPUTMATTYPE>
 16 | class DistNMF : public NMF<INPUTMATTYPE> {
 17 |  protected:
 18 |   const MPICommunicator &m_mpicomm;
 19 | #ifdef USE_PACOSS
 20 |   Pacoss_Communicator<double> *m_rowcomm;
 21 |   Pacoss_Communicator<double> *m_colcomm;
 22 | #endif
 23 |   UWORD m_ownedm;
 24 |   UWORD m_ownedn;
 25 |   UWORD m_globalm;
 26 |   UWORD m_globaln;
 27 |   double m_globalsqnormA;
 28 |   DistNMFTime time_stats;
 29 |   uint m_compute_error;
 30 |   algotype m_algorithm;
 31 |   ROWVEC localWnorm;
 32 |   ROWVEC Wnorm;
 33 | 
 34 |  public:
 35 |   /**
 36 |    * There are totally prxpc process.
 37 |    * Each process will hold the following
 38 |    * @param[in] A of size \f$\frac{globalm}{p_r} \times \frac{globaln}{p_c}\f$
 39 |    * @param[in] right low rank factor H of size \f$\frac{globaln}{p} \times k\f$
 40 |    * @param[in] left low rank factor W of size \f$\frac{globalm}{p} \times k\f$
 41 |    * @param[in] MPI Communicator for row and column communicators
 42 |    */  
 43 |   DistNMF(const INPUTMATTYPE &input, const MAT &leftlowrankfactor,
 44 |           const MAT &rightlowrankfactor, const MPICommunicator &communicator)
 45 |       : NMF<INPUTMATTYPE>(input, leftlowrankfactor, rightlowrankfactor),
 46 |         m_mpicomm(communicator),
 47 |         time_stats(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) {
 48 |     double sqnorma = this->normA * this->normA;
 49 |     this->m_globalm = 0;
 50 |     this->m_globaln = 0;
 51 |     MPI_Allreduce(&sqnorma, &(this->m_globalsqnormA), 1, MPI_DOUBLE, MPI_SUM,
 52 |                   MPI_COMM_WORLD);
 53 |     this->m_ownedm = this->W.n_rows;
 54 |     this->m_ownedn = this->H.n_rows;
 55 | #ifdef USE_PACOSS
 56 |     // TODO(kayaogz): This is a hack for now. Talk to Ramki.
 57 |     this->m_globalm = this->W.n_rows * this->m_mpicomm.size();
 58 |     this->m_globaln = this->H.n_rows * this->m_mpicomm.size();
 59 | #else
 60 |     MPI_Allreduce(&(this->m), &(this->m_globalm), 1, MPI_INT, MPI_SUM,
 61 |                   this->m_mpicomm.commSubs()[0]);
 62 |     MPI_Allreduce(&(this->n), &(this->m_globaln), 1, MPI_INT, MPI_SUM,
 63 |                   this->m_mpicomm.commSubs()[1]);
 64 | #endif
 65 |     if (ISROOT) {
 66 |       INFO << "globalsqnorma::" << this->m_globalsqnormA
 67 |            << "::globalm::" << this->m_globalm
 68 |            << "::globaln::" << this->m_globaln << std::endl;
 69 |     }
 70 |     this->m_compute_error = 0;
 71 |     localWnorm.zeros(this->k);
 72 |     Wnorm.zeros(this->k);
 73 |   }
 74 | 
 75 | #ifdef USE_PACOSS
 76 |   void set_rowcomm(Pacoss_Communicator<double> *rowcomm) {
 77 |     this->m_rowcomm = rowcomm;
 78 |   }
 79 |   void set_colcomm(Pacoss_Communicator<double> *colcomm) {
 80 |     this->m_colcomm = colcomm;
 81 |   }
 82 | #endif
 83 |   /// returns globalm
 84 |   const int globalm() const { return m_globalm; }
 85 |   /// returns globaln
 86 |   const int globaln() const { return m_globaln; }
 87 |   /// returns global squared norm of A
 88 |   const double globalsqnorma() const { return m_globalsqnormA; }
 89 |   /// return the current error
 90 |   void compute_error(const uint &ce) { this->m_compute_error = ce; }
 91 |   /// returns the flag to compute error or not.
 92 |   const bool is_compute_error() const { return (this->m_compute_error); }
 93 |   /// returns the NMF algorithm
 94 |   void algorithm(algotype dat) { this->m_algorithm = dat; }
 95 |   /// Reports the time
 96 |   void reportTime(const double temp, const std::string &reportstring) {
 97 |     double mintemp, maxtemp, sumtemp;
 98 |     MPI_Allreduce(&temp, &maxtemp, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
 99 |     MPI_Allreduce(&temp, &mintemp, 1, MPI_DOUBLE, MPI_MIN, MPI_COMM_WORLD);
100 |     MPI_Allreduce(&temp, &sumtemp, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
101 |     PRINTROOT(reportstring << "::m::" << this->m_globalm
102 |                            << "::n::" << this->m_globaln << "::k::" << this->k
103 |                            << "::SIZE::" << MPI_SIZE
104 |                            << "::algo::" << this->m_algorithm
105 |                            << "::root::" << temp << "::min::" << mintemp
106 |                            << "::avg::" << (sumtemp) / (MPI_SIZE)
107 |                            << "::max::" << maxtemp);
108 |   }
109 |   /// Column Normalizes the distributed W matrix
110 |   void normalize_by_W() {
111 |     localWnorm = sum(this->W % this->W);
112 |     mpitic();
113 |     MPI_Allreduce(localWnorm.memptr(), Wnorm.memptr(), this->k, MPI_DOUBLE,
114 |                   MPI_SUM, MPI_COMM_WORLD);
115 |     double temp = mpitoc();
116 |     this->time_stats.allgather_duration(temp);
117 |     for (int i = 0; i < this->k; i++) {
118 |       if (Wnorm(i) > 1) {
119 |         double norm_const = sqrt(Wnorm(i));
120 |         this->W.col(i) = this->W.col(i) / norm_const;
121 |         this->H.col(i) = norm_const * this->H.col(i);
122 |       }
123 |     }
124 |   }
125 | 
126 |   DistNMFTime * times() {
127 |     return new DistNMFTime(this->time_stats);
128 |   }
129 | };
130 | 
131 | }  // namespace planc
132 | 
133 | #endif  // DISTNMF_DISTNMF_HPP_
134 | 


--------------------------------------------------------------------------------
/distnmf/distnmftime.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 Ramakrishnan Kannan */
  2 | 
  3 | #ifndef DISTNMF_DISTNMFTIME_HPP_
  4 | #define DISTNMF_DISTNMFTIME_HPP_
  5 | 
  6 | /**
  7 |  * Class and function for collecting time statistics 
  8 |  */
  9 | 
 10 | namespace planc {
 11 | 
 12 | class DistNMFTime {
 13 |  private:
 14 |   double m_duration;
 15 |   double m_compute_duration;
 16 |   double m_communication_duration;
 17 |   double m_allgather_duration;
 18 |   double m_allreduce_duration;
 19 |   double m_reducescatter_duration;
 20 |   double m_sendrecv_duration;
 21 |   double m_gram_duration;
 22 |   double m_nongram_duration;
 23 |   double m_mm_duration;
 24 |   double m_nnls_duration;
 25 |   double m_err_compute_duration;
 26 |   double m_err_communication_duration;
 27 |   double m_gradient_duration;
 28 |   double m_cg_duration;
 29 |   double m_projection_duration;
 30 | 
 31 |  public:
 32 |   DistNMFTime(double d, double compute_d, double communication_d,
 33 |               double err_comp, double err_comm)
 34 |       : m_duration(d),
 35 |         m_compute_duration(compute_d),
 36 |         m_communication_duration(communication_d),
 37 |         m_err_compute_duration(err_comp),
 38 |         m_err_communication_duration(err_comm) {}
 39 |   DistNMFTime(double d, double compute_d, double communication_d,
 40 |               double allgather_d, double allreduce_d, double reducescatter_d,
 41 |               double gram_d, double mm_d, double nnls_d, double err_comp,
 42 |               double err_comm, double sr_d)
 43 |       : m_duration(d),
 44 |         m_compute_duration(compute_d),
 45 |         m_communication_duration(communication_d),
 46 |         m_allgather_duration(allgather_d),
 47 |         m_allreduce_duration(allreduce_d),
 48 |         m_reducescatter_duration(reducescatter_d),
 49 |         m_gram_duration(gram_d),
 50 |         m_mm_duration(mm_d),
 51 |         m_nnls_duration(nnls_d),
 52 |         m_err_compute_duration(err_comp),
 53 |         m_err_communication_duration(err_comm),
 54 |         m_sendrecv_duration(sr_d) {
 55 |           // Initial optional variables to 0
 56 |           m_nongram_duration = 0.0;
 57 |           m_gradient_duration = 0.0;
 58 |           m_cg_duration = 0.0;
 59 |           m_projection_duration = 0.0;
 60 |         }
 61 |   DistNMFTime(double d, double compute_d, double communication_d, double gram_d,
 62 |               double mm_d, double nnls_d, double err_comp, double err_comm)
 63 |       : m_duration(d),
 64 |         m_compute_duration(compute_d),
 65 |         m_communication_duration(communication_d),
 66 |         m_gram_duration(gram_d),
 67 |         m_mm_duration(mm_d),
 68 |         m_nnls_duration(nnls_d),
 69 |         m_err_compute_duration(err_comp),
 70 |         m_err_communication_duration(err_comm) {
 71 |           // Initial optional variables to 0
 72 |           m_allgather_duration = 0.0;
 73 |           m_allreduce_duration = 0.0;
 74 |           m_reducescatter_duration = 0.0;
 75 |           m_sendrecv_duration = 0.0;
 76 |           m_nongram_duration = 0.0;
 77 |           m_gradient_duration = 0.0;
 78 |           m_cg_duration = 0.0;
 79 |           m_projection_duration = 0.0;
 80 |         }
 81 |   // Getter Functions
 82 |   const double duration() const { return m_duration; }
 83 |   const double compute_duration() const { return m_compute_duration; }
 84 |   const double communication_duration() const {
 85 |     return m_communication_duration;
 86 |   }
 87 |   const double allgather_duration() const { return m_allgather_duration; }
 88 |   const double allreduce_duration() const { return m_allreduce_duration; }
 89 |   const double reducescatter_duration() const {
 90 |     return m_reducescatter_duration;
 91 |   }
 92 |   const double sendrecv_duration() const { return m_sendrecv_duration; }
 93 |   const double gram_duration() const { return m_gram_duration; }
 94 |   const double nongram_duration() const { return m_nongram_duration; }
 95 |   const double mm_duration() const { return m_mm_duration; }
 96 |   const double nnls_duration() const { return m_nnls_duration; }
 97 |   const double err_compute_duration() const { return m_err_compute_duration; }
 98 |   const double err_communication_duration() const {
 99 |     return m_err_communication_duration;
100 |   }
101 |   const double gradient_duration() const { return m_gradient_duration; }
102 |   const double cg_duration() const { return m_cg_duration; }
103 |   const double projection_duration() const { return m_projection_duration; }
104 |   // Update Functions
105 |   void duration(double d) { m_duration += d; }
106 |   void compute_duration(double d) { m_compute_duration += d; }
107 |   void communication_duration(double d) { m_communication_duration += d; }
108 |   void allgather_duration(double d) { m_allgather_duration += d; }
109 |   void allreduce_duration(double d) { m_allreduce_duration += d; }
110 |   void reducescatter_duration(double d) { m_reducescatter_duration += d; }
111 |   void sendrecv_duration(double d) { m_sendrecv_duration += d; }
112 |   void gram_duration(double d) { m_gram_duration += d; }
113 |   void nongram_duration(double d) { m_nongram_duration += d; }
114 |   void mm_duration(double d) { m_mm_duration += d; }
115 |   void nnls_duration(double d) { m_nnls_duration += d; }
116 |   void err_compute_duration(double d) { m_err_compute_duration += d; }
117 |   void err_communication_duration(double d) {
118 |     m_err_communication_duration += d;
119 |   }
120 |   void gradient_duration(double d) { m_gradient_duration += d; }
121 |   void cg_duration(double d) { m_cg_duration += d; }
122 |   void projection_duration(double d) { m_projection_duration += d; }
123 | };
124 | 
125 | }  // namespace planc
126 | 
127 | #endif  // DISTNMF_DISTNMFTIME_HPP_
128 | 


--------------------------------------------------------------------------------
/distjointnmf/distjnmftime.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2022 Ramakrishnan Kannan */
  2 | 
  3 | #ifndef DISTNMF_DISTJNMFTIME_HPP_
  4 | #define DISTNMF_DISTJNMFTIME_HPP_
  5 | 
  6 | /**
  7 |  * Class and function for collecting time statistics 
  8 |  */
  9 | 
 10 | namespace planc {
 11 | 
 12 | class DistJointNMFTime {
 13 |  private:
 14 |   double m_duration;
 15 |   double m_compute_duration;
 16 |   double m_communication_duration;
 17 |   double m_allgather_duration;
 18 |   double m_allreduce_duration;
 19 |   double m_reducescatter_duration;
 20 |   double m_sendrecv_duration;
 21 |   double m_gram_duration;
 22 |   double m_reg_duration;
 23 |   double m_nongram_duration;
 24 |   double m_mm_duration;
 25 |   double m_nnls_duration;
 26 |   double m_err_compute_duration;
 27 |   double m_err_communication_duration;
 28 |   
 29 |   // Matmul times
 30 |   double m_WtA_compute_duration;
 31 |   double m_WtA_communication_duration;
 32 |   double m_AH_compute_duration;
 33 |   double m_AH_communication_duration;
 34 |   double m_SHs_compute_duration;
 35 |   double m_SHs_communication_duration;
 36 | 
 37 |   // ANLS times
 38 |   double m_H2tS_compute_duration;
 39 |   double m_H2tS_communication_duration;
 40 | 
 41 |  public:
 42 |   DistJointNMFTime() {
 43 |     // Initialise all the breakdown timers
 44 |     this->m_duration = 0.0;
 45 |     this->m_compute_duration = 0.0;
 46 |     this->m_communication_duration = 0.0;
 47 |     this->m_allgather_duration = 0.0;
 48 |     this->m_allreduce_duration = 0.0;
 49 |     this->m_reducescatter_duration = 0.0;
 50 |     this->m_sendrecv_duration = 0.0;
 51 |     this->m_gram_duration = 0.0;
 52 |     this->m_reg_duration = 0.0;
 53 |     this->m_nongram_duration = 0.0;
 54 |     this->m_mm_duration = 0.0;
 55 |     this->m_nnls_duration = 0.0;
 56 |     this->m_err_compute_duration = 0.0;
 57 |     this->m_err_communication_duration = 0.0;
 58 | 
 59 |     // Matmul times
 60 |     this->m_WtA_compute_duration = 0.0;
 61 |     this->m_WtA_communication_duration = 0.0;
 62 |     this->m_AH_compute_duration = 0.0;
 63 |     this->m_AH_communication_duration = 0.0;
 64 |     this->m_SHs_compute_duration = 0.0;
 65 |     this->m_SHs_communication_duration = 0.0;
 66 | 
 67 |     // ANLS times
 68 |     this->m_H2tS_compute_duration = 0.0;
 69 |     this->m_H2tS_communication_duration = 0.0;
 70 |    }
 71 |   // Getter Functions
 72 |   const double duration() const { return m_duration; }
 73 |   const double compute_duration() const { return m_compute_duration; }
 74 |   const double communication_duration() const {
 75 |     return m_communication_duration;
 76 |   }
 77 |   const double allgather_duration() const { return m_allgather_duration; }
 78 |   const double allreduce_duration() const { return m_allreduce_duration; }
 79 |   const double reducescatter_duration() const {
 80 |     return m_reducescatter_duration;
 81 |   }
 82 |   const double sendrecv_duration() const { return m_sendrecv_duration; }
 83 |   const double gram_duration() const { return m_gram_duration; }
 84 |   const double reg_duration() const { return m_reg_duration; }
 85 |   const double nongram_duration() const { return m_nongram_duration; }
 86 |   const double mm_duration() const { return m_mm_duration; }
 87 |   const double nnls_duration() const { return m_nnls_duration; }
 88 |   const double err_compute_duration() const { return m_err_compute_duration; }
 89 |   const double err_communication_duration() const {
 90 |     return m_err_communication_duration;
 91 |   }
 92 |   const double WtA_compute_duration() const { return m_WtA_compute_duration; }
 93 |   const double WtA_communication_duration() const { 
 94 |     return m_WtA_communication_duration; 
 95 |   }
 96 |   const double AH_compute_duration() const { return m_AH_compute_duration; }
 97 |   const double AH_communication_duration() const { 
 98 |     return m_AH_communication_duration; 
 99 |   }
100 |   const double SHs_compute_duration() const { return m_SHs_compute_duration; }
101 |   const double SHs_communication_duration() const { 
102 |     return m_SHs_communication_duration; 
103 |   }
104 |   const double H2tS_compute_duration() const {
105 |     return m_H2tS_compute_duration; }
106 |   const double H2tS_communication_duration() const { 
107 |     return m_H2tS_communication_duration; 
108 |   }
109 |   // Update Functions
110 |   void duration(double d) { m_duration += d; }
111 |   void compute_duration(double d) { m_compute_duration += d; }
112 |   void communication_duration(double d) { m_communication_duration += d; }
113 |   void allgather_duration(double d) { m_allgather_duration += d; }
114 |   void allreduce_duration(double d) { m_allreduce_duration += d; }
115 |   void reducescatter_duration(double d) { m_reducescatter_duration += d; }
116 |   void sendrecv_duration(double d) { m_sendrecv_duration += d; }
117 |   void gram_duration(double d) { m_gram_duration += d; }
118 |   void reg_duration(double d) { m_reg_duration += d; }
119 |   void nongram_duration(double d) { m_nongram_duration += d; }
120 |   void mm_duration(double d) { m_mm_duration += d; }
121 |   void nnls_duration(double d) { m_nnls_duration += d; }
122 |   void err_compute_duration(double d) { m_err_compute_duration += d; }
123 |   void err_communication_duration(double d) {
124 |     m_err_communication_duration += d;
125 |   }
126 |   void WtA_compute_duration(double d) { m_WtA_compute_duration += d; }
127 |   void WtA_communication_duration(double d) { 
128 |     m_WtA_communication_duration += d; 
129 |   }
130 |   void AH_compute_duration(double d) { m_AH_compute_duration += d; }
131 |   void AH_communication_duration(double d) { 
132 |     m_AH_communication_duration += d; 
133 |   }
134 |   void SHs_compute_duration(double d) { m_SHs_compute_duration += d; }
135 |   void SHs_communication_duration(double d) { 
136 |     m_SHs_communication_duration += d; 
137 |   }
138 |   void H2tS_compute_duration(double d) { m_H2tS_compute_duration += d; }
139 |   void H2tS_communication_duration(double d) { 
140 |     m_H2tS_communication_duration += d; 
141 |   }
142 | };
143 | 
144 | }  // namespace planc
145 | 
146 | #endif  // DISTNMF_DISTNMFTIME_HPP_
147 | 


--------------------------------------------------------------------------------
/distntf/distntfaoadmm.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright Ramakrishnan Kannan 2018 */
  2 | 
  3 | #ifndef DISTNTF_DISTNTFAOADMM_HPP_
  4 | #define DISTNTF_DISTNTFAOADMM_HPP_
  5 | 
  6 | #include "distntf/distauntf.hpp"
  7 | 
  8 | namespace planc {
  9 | 
 10 | class DistNTFAOADMM : public DistAUNTF {
 11 |  private:
 12 |   // ADMM auxiliary variables
 13 |   NCPFactors m_local_ncp_aux;
 14 |   NCPFactors m_local_ncp_aux_t;
 15 |   NCPFactors m_temp_local_ncp_aux_t;
 16 |   MAT L;
 17 |   MAT Lt;
 18 |   MAT tempgram;
 19 |   int admm_iter;
 20 |   double tolerance;
 21 |   double chol_time;
 22 |   double stop_iter_time;
 23 |   double proj_time;
 24 |   double solve_time;
 25 |   double norm_time;
 26 | 
 27 |  protected:
 28 |   /**
 29 |    * This is ADMM based update function.
 30 |    * Given the MTTKRP and the hadamard of all the grams, we
 31 |    * determine the factor matrix to be updated.
 32 |    * @param[in] Mode of the factor to be updated
 33 |    * @returns The new updated factor
 34 |    */
 35 |   MAT update(const int mode) {
 36 |     // return variable
 37 |     MAT updated_fac(this->m_local_ncp_factors.factor(mode));
 38 |     MAT prev_fac = updated_fac;
 39 | 
 40 |     // Set up ADMM iteration
 41 |     double alpha = 0.0;
 42 | 
 43 |     MPITIC;
 44 |     if (m_nls_sizes[mode] > 0) {
 45 |       alpha = arma::trace(this->global_gram) / this->m_local_ncp_factors.rank();
 46 |       alpha = (alpha > 0) ? alpha : 0.01;
 47 |       tempgram = this->global_gram;
 48 |       tempgram.diag() += alpha;
 49 |       L = arma::chol(tempgram, "lower");
 50 |       Lt = L.t();
 51 |     }
 52 |     chol_time += MPITOC;
 53 |     bool stop_iter = false;
 54 | 
 55 |     // Start ADMM loop from here
 56 |     for (int i = 0; i < admm_iter && !stop_iter; i++) {
 57 |       MPITIC;
 58 |       if (m_nls_sizes[mode] > 0) {
 59 |         prev_fac = updated_fac;
 60 |         m_local_ncp_aux_t.set(mode, m_local_ncp_aux.factor(mode).t());
 61 |         m_temp_local_ncp_aux_t.set(
 62 |             mode, arma::solve(arma::trimatl(L),
 63 |                               this->ncp_local_mttkrp_t[mode] +
 64 |                                   (alpha * (updated_fac.t() +
 65 |                                             m_local_ncp_aux_t.factor(mode)))));
 66 |         m_local_ncp_aux_t.set(mode,
 67 |                               arma::solve(arma::trimatu(Lt),
 68 |                                           m_temp_local_ncp_aux_t.factor(mode)));
 69 |         // Update factor matrix
 70 |         updated_fac = m_local_ncp_aux_t.factor(mode).t();
 71 |         // Uncomment if numerical issues are seen
 72 |         // fixNumericalError<MAT>(&(updated_fac), EPSILON_1EMINUS16, 0.0);
 73 |         updated_fac = updated_fac - m_local_ncp_aux.factor(mode);
 74 |         updated_fac.for_each(
 75 |             [](MAT::elem_type &val) { val = val > 0.0 ? val : 0.0; });
 76 |         // Update dual variable
 77 |         m_local_ncp_aux.set(mode, m_local_ncp_aux.factor(mode) + updated_fac -
 78 |                                       m_local_ncp_aux_t.factor(mode).t());
 79 |       }
 80 |       solve_time += MPITOC;
 81 |       // stopping criteria variables
 82 |       double local_facnorm = 0.0;
 83 |       double local_dualnorm = 0.0;
 84 |       double r = 0.0;
 85 |       double s = 0.0;
 86 |       if (m_nls_sizes[mode] > 0) {
 87 |         local_facnorm = arma::norm(updated_fac, "fro");
 88 |         local_dualnorm = arma::norm(m_local_ncp_aux.factor(mode), "fro");
 89 |         r = norm(updated_fac.t() - m_local_ncp_aux_t.factor(mode), "fro");
 90 |         s = norm(updated_fac - prev_fac, "fro");
 91 |       }
 92 |       MPITIC;
 93 |       // factor norm
 94 |       local_facnorm *= local_facnorm;
 95 |       double global_facnorm = 0.0;
 96 |       MPI_Allreduce(&local_facnorm, &global_facnorm, 1, MPI_DOUBLE, MPI_SUM,
 97 |                     MPI_COMM_WORLD);
 98 |       global_facnorm = sqrt(global_facnorm);
 99 | 
100 |       // dual norm
101 |       local_dualnorm *= local_dualnorm;
102 |       double global_dualnorm = 0.0;
103 |       MPI_Allreduce(&local_dualnorm, &global_dualnorm, 1, MPI_DOUBLE, MPI_SUM,
104 |                     MPI_COMM_WORLD);
105 |       global_dualnorm = sqrt(global_dualnorm);
106 | 
107 |       // Check stopping criteria (needs communication)
108 |       r *= r;
109 |       double global_r = 0.0;
110 |       MPI_Allreduce(&r, &global_r, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
111 |       global_r = sqrt(global_r);
112 | 
113 |       s *= s;
114 |       double global_s = 0.0;
115 |       MPI_Allreduce(&s, &global_s, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
116 |       global_s = sqrt(global_s);
117 |       if (global_r < (tolerance * global_facnorm) &&
118 |           global_s < (tolerance * global_dualnorm))
119 |         stop_iter = true;
120 |       stop_iter_time += MPITOC;
121 |     }
122 |     MPITIC;
123 |     m_local_ncp_aux.distributed_normalize(mode);
124 |     norm_time += MPITOC;
125 |     return updated_fac.t();
126 |   }
127 | 
128 |  public:
129 |   DistNTFAOADMM(const Tensor &i_tensor, const int i_k, algotype i_algo,
130 |                 const UVEC &i_global_dims, const UVEC &i_local_dims,
131 |                 const UVEC &i_nls_sizes, const UVEC &i_nls_idxs,
132 |                 const NTFMPICommunicator &i_mpicomm)
133 |       : DistAUNTF(i_tensor, i_k, i_algo, i_global_dims, i_local_dims,
134 |                   i_nls_sizes, i_nls_idxs, i_mpicomm),
135 |         m_local_ncp_aux(i_nls_sizes, i_k, false),
136 |         m_local_ncp_aux_t(i_nls_sizes, i_k, true),
137 |         m_temp_local_ncp_aux_t(i_nls_sizes, i_k, true) {
138 |     m_local_ncp_aux.zeros();
139 |     m_local_ncp_aux_t.zeros();
140 |     m_temp_local_ncp_aux_t.zeros();
141 |     L.zeros(i_k, i_k);
142 |     Lt.zeros(i_k, i_k);
143 |     tempgram.zeros(i_k, i_k);
144 |     admm_iter = 5;
145 |     tolerance = 0.01;
146 |     chol_time = 0.0;
147 |     stop_iter_time = 0.0;
148 |     solve_time = 0.0;
149 |     norm_time = 0.0;
150 |   }
151 | 
152 |   ~DistNTFAOADMM() {
153 |     PRINTROOT("::chol time::" << chol_time
154 |                               << "::stop_iter_time::" << stop_iter_time
155 |                               << "::solve_time::" << solve_time
156 |                               << "::norm_time::" << norm_time);
157 |   }
158 | 
159 | };  // class DistNTFAOADMM
160 | 
161 | }  // namespace planc
162 | 
163 | #endif  // DISTNTF_DISTNTFAOADMM_HPP_
164 | 


--------------------------------------------------------------------------------
/nmf/aoadmm.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 Ramakrishnan Kannan */
  2 | 
  3 | #ifndef NMF_AOADMM_HPP_
  4 | #define NMF_AOADMM_HPP_
  5 | 
  6 | #include "common/nmf.hpp"
  7 | 
  8 | namespace planc {
  9 | 
 10 | template <class T>
 11 | class AOADMMNMF : public NMF<T> {
 12 |  private:
 13 |   // Not happy with this design. However to avoid computing At again and again
 14 |   // making this as private variable.
 15 |   T At;
 16 |   MAT WtW;
 17 |   MAT HtH;
 18 |   MAT WtA;
 19 |   MAT AH;
 20 | 
 21 |   // Dual Variables
 22 |   MAT U;
 23 |   MAT V;
 24 | 
 25 |   // Auxiliary/Temporary Variables
 26 |   MAT Htaux;
 27 |   MAT tempHtaux;
 28 |   MAT H0;
 29 |   MAT Wtaux;
 30 |   MAT tempWtaux;
 31 |   MAT W0;
 32 |   MAT L;
 33 | 
 34 |   // Hyperparameters
 35 |   double alpha, beta, tolerance;
 36 |   int admm_iter;
 37 | 
 38 |   /*
 39 |    * Collected statistics are
 40 |    * iteration Htime Wtime totaltime normH normW densityH densityW relError
 41 |    */
 42 |   void allocateMatrices() {
 43 |     WtW = arma::zeros<MAT>(this->k, this->k);
 44 |     HtH = arma::zeros<MAT>(this->k, this->k);
 45 |     WtA = arma::zeros<MAT>(this->n, this->k);
 46 |     AH = arma::zeros<MAT>(this->m, this->k);
 47 | 
 48 |     // Dual Variables
 49 |     U.zeros(size(this->W));
 50 |     V.zeros(size(this->H));
 51 | 
 52 |     // Auxiliary/Temporary Variables
 53 |     Htaux.zeros(size(this->H.t()));
 54 |     H0.zeros(size(this->H));
 55 |     tempHtaux.zeros(size(this->H.t()));
 56 |     Wtaux.zeros(size(this->W.t()));
 57 |     W0.zeros(size(this->W));
 58 |     tempWtaux.zeros(size(this->W.t()));
 59 |     L.zeros(this->k, this->k);
 60 | 
 61 |     // Hyperparameters
 62 |     alpha = 0.0;
 63 |     beta = 0.0;
 64 |     tolerance = 0.01;
 65 |     admm_iter = 5;
 66 |   }
 67 |   void freeMatrices() {
 68 |     this->At.clear();
 69 |     WtW.clear();
 70 |     HtH.clear();
 71 |     WtA.clear();
 72 |     AH.clear();
 73 |   }
 74 | 
 75 |  public:
 76 |   AOADMMNMF(const T &A, int lowrank) : NMF<T>(A, lowrank) {
 77 |     this->normalize_by_W();
 78 |     allocateMatrices();
 79 |   }
 80 |   AOADMMNMF(const T &A, const MAT &llf, const MAT &rlf) : NMF<T>(A, llf, rlf) {
 81 |     this->normalize_by_W();
 82 |     allocateMatrices();
 83 |   }
 84 |   void computeNMF() {
 85 |     unsigned int currentIteration = 0;
 86 |     this->At = this->A.t();
 87 |     INFO << "computed transpose At=" << PRINTMATINFO(this->At) << std::endl;
 88 |     while (currentIteration < this->num_iterations()) {
 89 |       tic();
 90 |       // update H
 91 |       tic();
 92 |       WtA = this->W.t() * this->A;
 93 |       WtW = this->W.t() * this->W;
 94 |       this->applyReg(this->regH(), &this->WtW);
 95 |       beta = trace(WtW) / this->k;
 96 |       beta = beta > 0 ? beta : 0.01;
 97 |       WtW.diag() += beta;
 98 | 
 99 |       INFO << "starting H Prereq for "
100 |            << " took=" << toc() << PRINTMATINFO(WtW) << PRINTMATINFO(WtA)
101 |            << std::endl;
102 |       // to avoid divide by zero error.
103 |       tic();
104 |       L = arma::chol(WtW, "lower");
105 | 
106 |       bool stop_iter = false;
107 | 
108 |       // Start ADMM loop from here
109 |       for (int i = 0; i < admm_iter && !stop_iter; i++) {
110 |         H0 = this->H;
111 |         tempHtaux =
112 |             arma::solve(arma::trimatl(L), WtA + (beta * (this->H.t() + V.t())));
113 |         Htaux = arma::solve(arma::trimatu(L.t()), tempHtaux);
114 | 
115 |         this->H = Htaux.t();
116 |         // Uncomment if numerical issues are seen
117 |         // fixNumericalError<MAT>(&(this->H), EPSILON_1EMINUS16, 0.0);
118 |         this->H = this->H - V;
119 |         this->H.for_each(
120 |             [](MAT::elem_type &val) { val = val > 0.0 ? val : 0.0; });
121 |         V = V + this->H - Htaux.t();
122 | 
123 |         // Check stopping criteria
124 |         double r = norm(this->H - Htaux.t(), "fro");
125 |         double s = norm(this->H - H0, "fro");
126 |         double normH = norm(this->H, "fro");
127 |         double normV = norm(V, "fro");
128 | 
129 |         if (r < (tolerance * normH) && s < (tolerance * normV))
130 |           stop_iter = true;
131 |       }
132 | 
133 |       INFO << "Completed H (" << currentIteration << "/"
134 |            << this->num_iterations() << ")"
135 |            << " time =" << toc() << std::endl;
136 | 
137 |       // update W;
138 |       tic();
139 |       AH = this->A * this->H;
140 |       HtH = this->H.t() * this->H;
141 |       this->applyReg(this->regW(), &this->HtH);
142 |       alpha = trace(HtH) / this->k;
143 |       alpha = alpha > 0 ? alpha : 0.01;
144 |       HtH.diag() += alpha;
145 | 
146 |       INFO << "starting W Prereq for "
147 |            << " took=" << toc() << PRINTMATINFO(HtH) << PRINTMATINFO(AH)
148 |            << std::endl;
149 |       tic();
150 |       L = arma::chol(HtH, "lower");
151 | 
152 |       stop_iter = false;
153 | 
154 |       // Start ADMM loop from here
155 |       for (int i = 0; i < admm_iter && !stop_iter; i++) {
156 |         W0 = this->W;
157 |         tempWtaux = arma::solve(arma::trimatl(L),
158 |                                 AH.t() + alpha * (this->W.t() + U.t()));
159 |         Wtaux = arma::solve(arma::trimatu(L.t()), tempWtaux);
160 | 
161 |         this->W = Wtaux.t();
162 |         // Uncomment if numerical issues are seen
163 |         // fixNumericalError<MAT>(&(this->W), EPSILON_1EMINUS16, 0.0);
164 |         this->W = this->W - U;
165 |         this->W.for_each(
166 |             [](MAT::elem_type &val) { val = val > 0.0 ? val : 0.0; });
167 | 
168 |         U = U + this->W - Wtaux.t();
169 | 
170 |         // Check stopping criteria
171 |         double r = norm(this->W - Wtaux.t(), "fro");
172 |         double s = norm(this->W - W0, "fro");
173 |         double normW = norm(this->W, "fro");
174 |         double normU = norm(U, "fro");
175 | 
176 |         if (r < (tolerance * normW) && s < (tolerance * normU))
177 |           stop_iter = true;
178 |       }
179 | 
180 |       INFO << "Completed W (" << currentIteration << "/"
181 |            << this->num_iterations() << ")"
182 |            << " time =" << toc() << std::endl;
183 | 
184 |       INFO << "Completed It (" << currentIteration << "/"
185 |            << this->num_iterations() << ")"
186 |            << " time =" << toc() << std::endl;
187 |       this->computeObjectiveError();
188 |       this->printObjective(currentIteration);
189 |       currentIteration++;
190 |     }
191 |   }
192 |   ~AOADMMNMF() {}
193 | };
194 | 
195 | }  // namespace planc
196 | 
197 | #endif  // NMF_AOADMM_HPP_
198 | 


--------------------------------------------------------------------------------
/ntf/ntfnes.hpp:
--------------------------------------------------------------------------------
  1 | /* Copyright Ramakrishnan Kannan 2018 */
  2 | 
  3 | #ifndef NTF_NTFNES_HPP_
  4 | #define NTF_NTFNES_HPP_
  5 | 
  6 | #include "ntf/auntf.hpp"
  7 | 
  8 | namespace planc {
  9 | class NTFNES : public AUNTF {
 10 |  private:
 11 |   // Update Variables
 12 |   NCPFactors m_prox_t;  // Proximal Term (H_*)
 13 |   NCPFactors m_acc_t;   // Acceleration term (Y)
 14 |   NCPFactors m_grad_t;  // Gradient Term (\nabla_f(Y))
 15 |   NCPFactors m_prev_t;  // Previous Iterate
 16 |   MAT modified_gram;
 17 |   // Termination Variables
 18 |   double delta1;  // Termination value for absmax
 19 |   double delta2;  // Termination value for min
 20 |   // Acceleration Variables
 21 |   int acc_start;   // Starting iteration for acceleration
 22 |   int acc_exp;     // Step size exponent
 23 |   int acc_fails;   // Acceleration Fails
 24 |   int fail_limit;  // Acceleration Fail limit
 25 | 
 26 |  protected:
 27 |   inline double get_lambda(double L, double mu) {
 28 |     double q = L / mu;
 29 |     double lambda = 0.0;
 30 | 
 31 |     if (q > 1e6)
 32 |       lambda = 10 * mu;
 33 |     else if (q > 1e3)
 34 |       lambda = mu;
 35 |     else
 36 |       lambda = mu / 10;
 37 | 
 38 |     return lambda;
 39 |   }
 40 | 
 41 |   inline double get_alpha(double alpha, double q) {
 42 |     /* Solves the quadratic equation
 43 |       x^2 + (\alpha^2 -q)x - \alpha^2 = 0
 44 |     */
 45 |     double a, b, c, D, x;
 46 |     a = 1.0;
 47 |     b = alpha * alpha - q;
 48 |     c = -alpha * alpha;
 49 |     D = b * b - 4 * a * c;
 50 |     x = (-b + sqrt(D)) / 2;
 51 |     return x;
 52 |   }
 53 | 
 54 |   bool stop_iter(const int mode) {
 55 |     bool stop = false;
 56 |     double absmax, amin;
 57 | 
 58 |     absmax = (arma::abs(m_grad_t.factor(mode) % m_acc_t.factor(mode))).max();
 59 |     amin = (m_grad_t.factor(mode)).min();
 60 | 
 61 |     if (absmax <= delta1 && amin >= -delta2) stop = true;
 62 | 
 63 |     return stop;
 64 |   }
 65 | 
 66 |   void accelerate() {
 67 |     int iter = this->current_it();
 68 |     if (iter > acc_start) {
 69 |       int num_modes = m_prox_t.modes();
 70 |       double cur_err = this->current_error();
 71 | 
 72 |       double acc_step = std::pow(iter + 1, (1.0 / acc_exp));
 73 |       // Adjust all the factors
 74 |       // Reusing gradient/acceleration term to save memory
 75 |       m_grad_t.zeros();
 76 |       int lowrank = m_prox_t.rank();
 77 |       MAT scalecur = arma::eye<MAT>(lowrank, lowrank);
 78 |       MAT scaleprev = arma::eye<MAT>(lowrank, lowrank);
 79 |       for (int mode = 0; mode < num_modes; mode++) {
 80 |         // Make only the last mode unnormalised
 81 |         if (mode == num_modes - 1) {
 82 |           scalecur = arma::diagmat(this->m_ncp_factors.lambda());
 83 |           scaleprev = arma::diagmat(m_prev_t.lambda());
 84 |         }
 85 |         // Step Matrix
 86 |         MAT acc_mat = m_grad_t.factor(mode);
 87 |         acc_mat = (scalecur * this->m_ncp_factors.factor(mode).t()) -
 88 |                   (scaleprev * m_prev_t.factor(mode));
 89 |         acc_mat *= acc_step;
 90 |         acc_mat += (scalecur * this->m_ncp_factors.factor(mode).t());
 91 |         m_acc_t.set(mode, acc_mat);
 92 |         m_acc_t.normalize_rows(mode);
 93 |       }
 94 |       // Compute Error
 95 |       double acc_err = this->computeObjectiveError(m_acc_t);
 96 | 
 97 |       // Acceleration Accepted
 98 |       if (acc_err < cur_err) {
 99 |         // Set proximal term to current term
100 |         for (int mode = 0; mode < num_modes; mode++) {
101 |           m_prox_t.set(mode, m_acc_t.factor(mode));
102 |           m_prox_t.normalize_rows(mode);
103 |         }
104 |         INFO << "Acceleration Successful::relative_error::" << acc_err
105 |              << std::endl;
106 |       } else {
107 |         // Acceleration Failed reset to prev iterate
108 |         this->reset(m_prox_t, true);
109 |         acc_fails++;
110 |         if (acc_fails > fail_limit) {
111 |           acc_fails = 0;
112 |           acc_exp++;
113 |         }
114 |         INFO << "Acceleration Failed::relative_error::" << acc_err << std::endl;
115 |       }
116 |     }
117 |   }
118 | 
119 |   MAT update(const int mode) {
120 |     double L, mu, lambda, q, alpha, alpha_prev, beta;
121 |     if (mode == 0) {
122 |       m_prev_t.set_lambda(m_prox_t.lambda());
123 |     }
124 |     m_prev_t.set(mode, m_prox_t.factor(mode));
125 |     MAT Ht(m_prox_t.factor(mode));
126 |     MAT Htprev = Ht;
127 |     m_acc_t.set(mode, Ht);
128 |     modified_gram = this->gram_without_one;
129 | 
130 |     VEC eigval = arma::eig_sym(modified_gram);
131 |     L = eigval.max();
132 |     mu = eigval.min();
133 |     lambda = get_lambda(L, mu);
134 |     modified_gram.diag() += lambda;
135 | 
136 |     q = (mu + lambda) / (L + lambda);
137 | 
138 |     MAT modified_local_mttkrp_t =
139 |         (-1 * lambda) * m_acc_t.factor(mode) - this->ncp_mttkrp_t[mode];
140 | 
141 |     alpha = 1;
142 |     alpha_prev = 1;
143 |     beta = 1;
144 | 
145 |     while (true) {
146 |       m_grad_t.set(mode, modified_local_mttkrp_t +
147 |                              (modified_gram * m_acc_t.factor(mode)));
148 |       if (stop_iter(mode)) break;
149 | 
150 |       Htprev = Ht;
151 |       Ht = m_acc_t.factor(mode) - ((1 / (L + lambda)) * m_grad_t.factor(mode));
152 |       // Uncomment if numerical issues are seen
153 |       // fixNumericalError<MAT>(&Ht, EPSILON_1EMINUS16, 0.0);
154 |       Ht.for_each([](MAT::elem_type &val) { val = val > 0.0 ? val : 0.0; });
155 |       alpha_prev = alpha;
156 |       alpha = get_alpha(alpha_prev, q);
157 |       beta =
158 |           (alpha_prev * (1 - alpha_prev)) / (alpha + alpha_prev * alpha_prev);
159 |       m_acc_t.set(mode, Ht + beta * (Ht - Htprev));
160 |     }
161 | 
162 |     m_prox_t.set(mode, Ht);
163 |     m_prox_t.normalize_rows(mode);
164 | 
165 |     return Ht;
166 |   }
167 | 
168 |  public:
169 |   NTFNES(const Tensor &i_tensor, const int i_k, algotype i_algo)
170 |       : AUNTF(i_tensor, i_k, i_algo),
171 |         m_prox_t(i_tensor.dimensions(), i_k, true),
172 |         m_acc_t(i_tensor.dimensions(), i_k, true),
173 |         m_grad_t(i_tensor.dimensions(), i_k, true),
174 |         m_prev_t(i_tensor.dimensions(), i_k, true) {
175 |     m_prox_t.zeros();
176 |     m_prev_t.zeros();
177 |     m_acc_t.zeros();
178 |     m_grad_t.zeros();
179 |     modified_gram.zeros(i_k, i_k);
180 |     delta1 = 1e-2;
181 |     delta2 = 1e-2;
182 |     acc_start = 5;
183 |     acc_exp = 3;
184 |     acc_fails = 0;
185 |     fail_limit = 5;
186 |     // Set Accerated to be true
187 |     this->accelerated(true);
188 |   }
189 | };  // class NTFNES
190 | }  // namespace planc
191 | 
192 | #endif  // NTF_NTFNES_HPP_
193 | 


--------------------------------------------------------------------------------
/hiernmf/hiernmf.cpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2020 Lawton Manning */
  2 | #include <fstream>
  3 | #include <queue>
  4 | #include <string>
  5 | #include <vector>
  6 | #include <cinttypes>
  7 | #include "common/distutils.hpp"
  8 | #include "common/parsecommandline.hpp"
  9 | #include "common/utils.hpp"
 10 | #include "distnmf/distio.hpp"
 11 | #include "distnmf/distr2.hpp"
 12 | #include "distnmf/mpicomm.hpp"
 13 | #include "hiernmf/node.hpp"
 14 | 
 15 | namespace planc {
 16 | 
 17 | class HierNMFDriver {
 18 |  private:
 19 |   int m_argc;
 20 |   char **m_argv;
 21 |   int m_k;
 22 |   UWORD m_globalm, m_globaln;
 23 |   std::string m_Afile_name;
 24 |   std::string m_outputfile_name;
 25 |   int m_num_it;
 26 |   int m_pr;
 27 |   int m_pc = 1;
 28 |   FVEC m_regW;
 29 |   FVEC m_regH;
 30 |   double m_sparsity;
 31 |   iodistributions m_distio;
 32 |   uint m_compute_error;
 33 |   int m_num_k_blocks;
 34 |   static const int kprimeoffset = 17;
 35 |   normtype m_input_normalization;
 36 |   MPICommunicator *mpicomm;
 37 |   ParseCommandLine *pc;
 38 | 
 39 | #ifdef BUILD_SPARSE
 40 |   RootNode<SP_MAT> *root;
 41 | #else
 42 |   RootNode<MAT> *root;
 43 | #endif
 44 | 
 45 |   void parseCommandLine() {
 46 |     pc = new ParseCommandLine(this->m_argc, this->m_argv);
 47 |     pc->parseplancopts();
 48 |     this->m_k = pc->lowrankk();
 49 |     this->m_Afile_name = pc->input_file_name();
 50 |     this->m_pr = pc->pr();
 51 |     this->m_pc = 1;
 52 |     this->m_sparsity = pc->sparsity();
 53 |     this->m_num_it = pc->iterations();
 54 |     this->m_distio = TWOD;
 55 |     this->m_regW = pc->regW();
 56 |     this->m_regH = pc->regH();
 57 |     this->m_num_k_blocks = 1;
 58 |     this->m_globalm = pc->globalm();
 59 |     this->m_globaln = pc->globaln();
 60 |     this->m_compute_error = pc->compute_error();
 61 |     this->m_outputfile_name = pc->output_file_name();
 62 |     pc->printConfig();
 63 |   }
 64 | 
 65 |   void buildTree() {
 66 |     std::string rand_prefix("rand_");
 67 |     this->mpicomm =
 68 |         new MPICommunicator(this->m_argc, this->m_argv, this->m_pr, this->m_pc);
 69 | 
 70 | #ifdef BUILD_SPARSE
 71 |     SP_MAT A;
 72 |     DistIO<SP_MAT> dio(*mpicomm, m_distio, A);
 73 | #else
 74 |     MAT A;
 75 |     DistIO<MAT> dio(*mpicomm, m_distio, A);
 76 | #endif
 77 | 
 78 |     if (m_Afile_name.compare(0, rand_prefix.size(), rand_prefix) == 0) {
 79 |       dio.readInput(m_Afile_name, this->m_globalm, this->m_globaln, this->m_k,
 80 |                     this->m_sparsity, this->m_pr, this->m_pc, 0, false, NONE);
 81 |     } else {
 82 |       dio.readInput(m_Afile_name, this->m_globalm, this->m_globaln, this->m_k,
 83 |                     this->m_sparsity, this->m_pr, this->m_pc, 0, false, NONE);
 84 |     }
 85 |     A = dio.A();
 86 | 
 87 |     MPI_Allreduce(&A.n_rows, &this->m_globalm, 1, MPI_UNSIGNED_LONG_LONG,
 88 |                   MPI_SUM, this->mpicomm->commSubs()[0]);
 89 |     MPI_Allreduce(&A.n_cols, &this->m_globaln, 1, MPI_UNSIGNED_LONG_LONG,
 90 |                   MPI_SUM, this->mpicomm->commSubs()[1]);
 91 | 
 92 |     int rank = this->mpicomm->rank();
 93 |     arma::uvec cols(this->m_globaln);
 94 |     for (unsigned int i = 0; i < this->m_globaln; i++) {
 95 |       cols[i] = i;
 96 |     }
 97 | 
 98 | #ifdef BUILD_SPARSE
 99 |     std::priority_queue<Node<SP_MAT> *, std::vector<Node<SP_MAT> *>,
100 |                         ScoreCompare>
101 |         frontiers;
102 |     Node<SP_MAT> *frontier;
103 |     Node<SP_MAT> *node;
104 | 
105 |     std::queue<Node<SP_MAT> *> nodes;
106 | #else
107 |     std::priority_queue<Node<MAT> *, std::vector<Node<MAT> *>, ScoreCompare>
108 |         frontiers;
109 |     Node<MAT> *frontier;
110 |     Node<MAT> *node;
111 | 
112 |     std::queue<Node<MAT> *> nodes;
113 | #endif
114 | 
115 |     mpitic();
116 | 
117 |     MPI_Barrier(MPI_COMM_WORLD);
118 |     memusage(mpicomm->rank(), "before root initialization");
119 | 
120 | #ifdef BUILD_SPARSE
121 |     this->root = new RootNode<SP_MAT>(&A, this->m_globalm, this->m_globaln,
122 |                                       cols, this->mpicomm, this->pc);
123 | #else
124 |     this->root = new RootNode<MAT>(&A, this->m_globalm, this->m_globaln, cols,
125 |                                    this->mpicomm, this->pc);
126 | #endif
127 | 
128 |     MPI_Barrier(MPI_COMM_WORLD);
129 |     memusage(mpicomm->rank(), "after root initialization");
130 | 
131 |     nodes.push(root);
132 | 
133 |     this->root->split();
134 |     this->root->accept();
135 |     this->root->enqueue_children(&frontiers);
136 |     this->root->enqueue_children(&nodes);
137 | 
138 |     for (int i = 2; i < pc->nodes(); i++) {
139 |       if (frontiers.empty()) {
140 |         break;
141 |       }
142 |       frontier = frontiers.top();
143 |       frontiers.pop();
144 |       frontier->accept();
145 |       frontier->enqueue_children(&frontiers);
146 |       frontier->enqueue_children(&nodes);
147 |     }
148 | 
149 |     double temp = mpitoc();
150 |     if (this->mpicomm->rank() == 0) {
151 |       printf("H2NMF took %.3lf secs.\n", temp);
152 |     }
153 | 
154 |     if (this->mpicomm->rank() == 0) {
155 |       printf(
156 |           "idx level m n NMF MATVEC(SIGMA) VECMAT(SIGMA) COMM(SIGMA) "
157 |           "NORM(SIGMA)\n");
158 |     }
159 |     while (!nodes.empty()) {
160 |       node = nodes.front();
161 |       nodes.pop();
162 |       if (this->mpicomm->rank() == 0) {
163 |         printf("%" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64
164 |                 " %f %f %f %f %f\n",
165 |               node->index, node->level,
166 |               node->global_m, node->global_n, node->timings.total,
167 |               node->timings.sigma.matvec, node->timings.sigma.vecmat,
168 |               node->timings.sigma.communication,
169 |               node->timings.sigma.normalisation);
170 |       }
171 |       if (node->index == 0) {
172 |         continue;
173 |       }
174 |       std::stringstream s;
175 |       s << this->m_outputfile_name << "_" << node->index;
176 |       dio.writeOutput(node->W, node->H, s.str());
177 |       if (this->mpicomm->rank() == 0) {
178 |         s << "_cols";
179 |         node->cols.save(s.str(), arma::raw_ascii);
180 |       }
181 |     }
182 |     MPI_Barrier(MPI_COMM_WORLD);
183 |     delete this->mpicomm;
184 |   }
185 | 
186 |  public:
187 |   HierNMFDriver(int argc, char *argv[]) {
188 |     this->m_argc = argc;
189 |     this->m_argv = argv;
190 |     this->parseCommandLine();
191 |     this->buildTree();
192 |   }
193 | };
194 | 
195 | }  // namespace planc
196 | 
197 | int main(int argc, char *argv[]) {
198 |   try {
199 |     planc::HierNMFDriver hd(argc, argv);
200 |     fflush(stdout);
201 |   } catch (const std::exception &e) {
202 |     INFO << "Exception with stack trace " << std::endl;
203 |     INFO << e.what();
204 |   }
205 | }
206 | 


--------------------------------------------------------------------------------
/distntf/distntf.cpp:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 Ramakrishnan Kannan */
  2 | 
  3 | #include <string>
  4 | #include "common/distutils.hpp"
  5 | #include "common/parsecommandline.hpp"
  6 | #include "common/tensor.hpp"
  7 | #include "common/utils.hpp"
  8 | #include "distntf/distauntf.hpp"
  9 | #include "distntf/distntfanlsbpp.hpp"
 10 | #include "distntf/distntfaoadmm.hpp"
 11 | #include "distntf/distntfcpals.hpp"
 12 | #include "distntf/distntfhals.hpp"
 13 | #include "distntf/distntfio.hpp"
 14 | #include "distntf/distntfmpicomm.hpp"
 15 | #include "distntf/distntfmu.hpp"
 16 | #include "distntf/distntfnes.hpp"
 17 | 
 18 | namespace planc {
 19 | class DistNTF {
 20 |  private:
 21 |   int m_argc;
 22 |   char **m_argv;
 23 |   int m_k;
 24 |   std::string m_Afile_name;
 25 |   std::string m_outputfile_name;
 26 |   int m_num_it;
 27 |   UVEC m_proc_grids;
 28 |   FVEC m_regs;
 29 |   algotype m_ntfalgo;
 30 |   double m_sparsity;
 31 |   uint m_compute_error;
 32 |   int m_num_k_blocks;
 33 |   UVEC m_global_dims;
 34 |   UVEC m_factor_local_dims;
 35 |   UVEC m_nls_sizes;
 36 |   UVEC m_nls_idxs;
 37 |   bool m_enable_dim_tree;
 38 |   static const int kprimeoffset = 17;
 39 | 
 40 |   void printConfig() {
 41 |     std::cout << "a::" << this->m_ntfalgo << "::i::" << this->m_Afile_name
 42 |               << "::k::" << this->m_k << "::dims::" << this->m_global_dims
 43 |               << "::t::" << this->m_num_it
 44 |               << "::proc_grids::" << this->m_proc_grids
 45 |               << "::error::" << this->m_compute_error
 46 |               << "::regs::" << this->m_regs
 47 |               << "::num_k_blocks::" << m_num_k_blocks
 48 |               << "::dim_tree::" << m_enable_dim_tree << std::endl;
 49 |   }
 50 | 
 51 |   template <class NTFTYPE>
 52 |   void callDistNTF() {
 53 |     planc::Tensor A;
 54 |     std::string rand_prefix("rand_");
 55 |     planc::NTFMPICommunicator mpicomm(this->m_argc, this->m_argv,
 56 |                                       this->m_proc_grids);
 57 |     mpicomm.printConfig();
 58 |     planc::DistNTFIO dio(mpicomm, A);
 59 |     dio.readInput(m_Afile_name, this->m_global_dims, this->m_proc_grids,
 60 |                     this->m_k, this->m_sparsity);
 61 |     this->m_global_dims = dio.global_dims();
 62 |     memusage(mpicomm.rank(), "after input io");
 63 |     INFO << mpicomm.rank()
 64 |          << "::Completed generating tensor A=" << A.dimensions()
 65 |          << "::start indices::" << A.global_idx()
 66 |          << "::global dims::" << this->m_global_dims << std::endl;
 67 | #ifdef DISTNTF_VERBOSE
 68 |     A.print();
 69 | #endif
 70 | #ifdef WRITE_RAND_INPUT
 71 |     dio.writeRandInput();
 72 | #endif  // ifdef WRITE_RAND_INPUT
 73 |         // same matrix as only one of them will be used.
 74 | 
 75 |     // sometimes for really very large matrices starting w/
 76 |     // rand initialization hurts ANLS BPP running time. For a better
 77 |     // initializer we run couple of iterations of HALS.
 78 | #ifdef MPI_VERBOSE
 79 |     INFO << mpicomm.rank() << "::" << __PRETTY_FUNCTION__
 80 |          << "::" << factors.printinfo() << std::endl;
 81 | #endif  // ifdef MPI_VERBOSE
 82 |     MPI_Barrier(MPI_COMM_WORLD);
 83 |     memusage(mpicomm.rank(), "b4 constructor ");
 84 |     // TODO(ramkikannan): I was here. Need to modify the reallocations by
 85 |     // using localOwnedRowCount instead of m_globalm.
 86 |     // DistAUNTF(const Tensor &i_tensor, const int i_k, algotype i_algo,
 87 |     //   const UVEC &i_global_dims,
 88 |     //   const UVEC &i_local_dims,
 89 |     //   const NTFMPICommunicator &i_mpicomm)
 90 |     // this->m_factor_local_dims = this->m_global_dims / mpicomm.size();
 91 |     this->m_factor_local_dims = A.dimensions();
 92 |     int num_modes = A.dimensions().n_rows;
 93 | 
 94 |     m_nls_sizes = arma::zeros<UVEC>(num_modes);
 95 |     m_nls_idxs = arma::zeros<UVEC>(num_modes);
 96 |     // Calculate NLS sizes
 97 |     for (int i = 0; i < num_modes; i++) {
 98 |       int slice_size = mpicomm.slice_size(i);
 99 |       int slice_rank = mpicomm.slice_rank(i);
100 |       int num_rows = this->m_factor_local_dims[i];
101 |       m_nls_sizes[i] = itersplit(num_rows, slice_size, slice_rank);
102 |       m_nls_idxs[i] = startidx(num_rows, slice_size, slice_rank);
103 |     }
104 | 
105 |     MPI_Barrier(MPI_COMM_WORLD);
106 | 
107 |     NTFTYPE ntfsolver(A, this->m_k, this->m_ntfalgo, this->m_global_dims,
108 |                       this->m_factor_local_dims, this->m_nls_sizes,
109 |                       this->m_nls_idxs, mpicomm);
110 |     memusage(mpicomm.rank(), "after constructor ");
111 |     ntfsolver.num_iterations(this->m_num_it);
112 |     ntfsolver.compute_error(this->m_compute_error);
113 |     if (this->m_enable_dim_tree) {
114 |       ntfsolver.dim_tree(this->m_enable_dim_tree);
115 |     }
116 |     ntfsolver.regularizers(this->m_regs);
117 |     MPI_Barrier(MPI_COMM_WORLD);
118 |     // try {
119 |     mpitic();
120 |     ntfsolver.computeNTF();
121 |     double temp = mpitoc();
122 |     A.clear();
123 |     if (!this->m_outputfile_name.empty()) {
124 |       dio.write(this->m_outputfile_name, &ntfsolver);
125 |     }
126 |     if (mpicomm.rank() == 0) {
127 |       printf("NTF took %.3lf secs.\n", temp);
128 |     }
129 |     // } catch (std::exception& e) {
130 |     //     printf("Failed rank %d: %s\n", mpicomm.rank(), e.what());
131 |     //     MPI_Abort(MPI_COMM_WORLD, 1);
132 |     // }
133 |   }
134 | 
135 |   void parseCommandLine() {
136 |     planc::ParseCommandLine pc(this->m_argc, this->m_argv);
137 |     pc.parseplancopts();
138 |     this->m_ntfalgo = pc.lucalgo();
139 |     this->m_k = pc.lowrankk();
140 |     this->m_Afile_name = pc.input_file_name();
141 |     this->m_proc_grids = pc.processor_grids();
142 |     this->m_sparsity = pc.sparsity();
143 |     this->m_num_it = pc.iterations();
144 |     this->m_num_k_blocks = 1;
145 |     this->m_regs = pc.regularizers();
146 |     this->m_global_dims = pc.dimensions();
147 |     this->m_compute_error = pc.compute_error();
148 |     this->m_enable_dim_tree = pc.dim_tree();
149 |     this->m_outputfile_name = pc.output_file_name();
150 |     printConfig();
151 |     switch (this->m_ntfalgo) {
152 |       case MU:
153 |         callDistNTF<DistNTFMU>();
154 |         break;
155 |       case HALS:
156 |         callDistNTF<DistNTFHALS>();
157 |         break;
158 |       case ANLSBPP:
159 |         callDistNTF<DistNTFANLSBPP>();
160 |         break;
161 |       case AOADMM:
162 |         callDistNTF<DistNTFAOADMM>();
163 |         break;
164 |       case NESTEROV:
165 |         callDistNTF<DistNTFNES>();
166 |         break;
167 |       case CPALS:
168 |         callDistNTF<DistNTFCPALS>();
169 |         break;
170 |       default:
171 |         ERR << "Wrong algorithm choice. Quitting.." << this->m_ntfalgo
172 |             << std::endl;
173 |     }
174 |   }
175 | 
176 |  public:
177 |   /// Driver function for the distntf
178 |   DistNTF(int argc, char *argv[]) {
179 |     this->m_argc = argc;
180 |     this->m_argv = argv;
181 |     this->parseCommandLine();
182 |   }
183 | };
184 | 
185 | }  // namespace planc
186 | 
187 | int main(int argc, char *argv[]) {
188 |   planc::DistNTF dnd(argc, argv);
189 |   fflush(stdout);
190 |   MPI_Barrier(MPI_COMM_WORLD);
191 |   MPI_Finalize();
192 | }
193 | 


--------------------------------------------------------------------------------