14:55 < zoq> I'm halfway through #825 ... a lot of code.

15:19 < rcurtin> yeah it is a huge amount, sorry to make so much work :P(

15:19 < rcurtin> ":(", accidentally hit the P somehow

15:26 < kartik_> hey thr .. ive written a cpp code after building mlpack from source. Ive added the paths too. by installing and the command line interface is working all fine.

15:26 < rcurtin> kartik_: glad to hear you got it working

15:28 < kartik_> thanks.. error comes when i run the c++ code which loads a matrix in csv also put in the same folder

15:28 < kartik_> in not able to build the source file sir

15:29 < kartik_> here is the error

15:29 < kartik_> In file included from /usr/include/c++/5/cstdint:35:0, from /usr/local/include/mlpack/prereqs.hpp:28, from /usr/local/include/mlpack/core.hpp:207, from mlpack_kartik.cpp:2: /usr/include/c++/5/bits/c++0x_warning.h:32:2: error: #error This file requires compiler and library support for the ISO C++ 2011 standard. This support must be enabled with the -std=c++11 or -std=gnu++11 compiler o

15:32 < rcurtin> "This support must be enabled with the -std=c++11 or -std=gnu++11 compiler"

15:33 < rcurtin> add -std=c++11 to your compiler flags :)

15:48 < kartik_> <rcurtin> i have a very long error while compiling .. but lets see if this fixes it ..thanks

15:48 < rcurtin> kartik_: yeah, often the first error is the only important one; lots of C++ compilers like to print tons and tons and tons of lines of error output

15:49 < rcurtin> sometimes I have seen up to 10000 lines of error output when compiling some mlpack code with a simple syntax error in it! :)

15:49 < kartik_> yeah its actually that 1000 one only .. :D

16:10 < kartik_> i used c11 flag this time .. but not ableto resolve issues

16:10 < kartik_> gcc -std=c++11 mlpack_kartik.cpp /tmp/cci1tNJa.o: In function `arma::arma_incompat_size_string(unsigned long long, unsigned long long, unsigned long long, unsigned long long, char const*)': mlpack_kartik.cpp:(.text+0x63): undefined reference to `std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char> >::basic_stringstream(std::_Ios_Openmode)'

16:11 < kartik_> my code just loads a matrix.csv file placed in the same folder and saves it again in a csv file..

16:11 < kartik_> should i reinstall mlpack from source..

16:12 < kartik_> sry for pasting such long silly errors..

16:13 < zoq> kartik__: You have to link against mlpack: 'g++ -std=c++11 -lmlpack -larmadillo mlpack_kartik.cpp'

16:22 < kartik_> $ g++ -std=c++11 -lmlpack -larmadillo mlpack_kartik.cpp /tmp/ccvD3aL0.o: In function `bool mlpack::data::Load<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, arma::Mat<double>&, bool, bool)':

16:23 < kartik_> here is my short code

16:23 < kartik_> #include <mlpack/core.hpp> using namespace mlpack; int main() { arma::mat data; data::Load("matrix.csv", data, true); arma::mat cov = data; data::Save("cov.csv", cov, true); }

16:26 < kartik_> <zoq> matrix.csv is in the same folder

16:27 < rcurtin> kartik_: that's a linker error, I'm not sure what is being linked against; take a closer look at the error

16:27 < rcurtin> maybe you need to link against a boost library like -lboost_program_options or -lboost_serialization

16:28 < zoq> Also do you build on mac OS?

16:28 < kartik_> ubuntu

16:36 < zoq> I remember that g++ is sometimes picky about the 'right' order. I guess this one is the correct one: g++ mlpack_kartik.cpp -std=c++11 -lmlpack -larmadillo -lboost_serialization -lboost_program_options

16:47 < rcurtin> kartik_: another thing you could do for linking is use pkg-config (if you have that installed)

16:47 < rcurtin> g++ mlpack_kartik.cpp -std=c++11 `pkg-config --libs mlpack`

16:48 < rcurtin> I think that will work... we recently started shipping pkg-config .pc files, so maybe that will work... maybe :)

16:50 < kartik_> thanks a lot curtin ..it worked awesome

16:50 < rcurtin> oh, pkg-config worked?

16:51 < kartik_> yes it did..got the a.out file :)

16:51 < rcurtin> ok, great, I will keep that in mind in the future then

16:52 < kartik_> just one more silly stuff.. ive build and installed both the 2.1 version and the master version of mlpack

16:52 < kartik_> i hope it wont create any troubles inthe future

16:56 < rcurtin> that may cause a problem, but I am not certain

16:57 < kartik_> ohkae .. thanks :)

22:01 < cult-> hi, anyone here?

22:12 < rcurtin> cult-: hi there, I am here now

22:12 < cult-> hi

22:12 < rcurtin> maybe others too but I can only speak for myself :)

22:13 < cult-> my question is for HMM, you have gaussian distribution. i can't get over this. how should I define the distribution for my training data? i tried to use HMM<GMM> or just simply HMM<GaussianDistribution> hmm(3, GaussianDistribution(2)); but everytime the viterbi just returned 0's

22:13 < cult-> if i have everything in place with HMM<GaussianDistribution> hmm(initial, transition, emission); i get proper viterbi, but i have no idea how to define the distribution there from the data

22:14 < rcurtin> the hmm(3, GaussianDistribution(2)) call will give you a working HMM object but you'll need to call Train() with your data to make it a meaningful model

22:15 < rcurtin> I'm not sure I know what you mean by "define the distribution there from the data"

22:15 < cult-> well ok i did the training too, unlabeled

22:15 < cult-> then, i take the same observations for the Predict, and i expect that will return the states from the data (i predict on the training data)

22:15 < cult-> but no, just 0s

22:18 < rcurtin> I know that HMMs default-initialize the transition matrix to 1/numClasses for each element

22:18 < rcurtin> after you train, what are the initial and transition matrices?

22:18 < rcurtin> you can access them with hmm.Initial() and hmm.Transition()

22:18 < cult-> one moment

22:19 < rcurtin> there is some similar code to what you are doing as a test: src/mlpack/tests/hmm_test.cpp, line 655

22:20 < rcurtin> so it's definitely possible to train a GaussianDistribution HMM on unlabeled data

22:20 < rcurtin> we just need to figure out what's different between the two situations :)

22:20 < cult-> how can i print hmm.Transition() ?

22:21 < cult-> just access each element?

22:22 < rcurtin> std::cout << hmm.Transition() :)

22:22 < rcurtin> (or whatever stream you like)

22:22 < rcurtin> the Armadillo matrices are nice like that, they support output to streams

22:22 < cult-> ah sorry, i did it just too much output

22:22 < rcurtin> hm, shouldn't it be a 3x3 matrix?

22:23 < cult-> yes

22:23 < cult-> 0.3333

22:23 < cult-> 0.3333

22:23 < cult-> 0.3333

22:23 < cult-> and the same with 3x3

22:23 < cult-> thats fine

22:23 < cult-> but what about the emissions?

22:25 < cult-> mean: -1.0114

22:25 < cult-> -1.0422

22:25 < cult-> covariance: 19.3383 18.4243

22:25 < cult-> 18.4243 19.4789

22:25 < cult-> so everything's fine, but when i do hmm.Predict(observations[0], predictions); each predictions are 0

22:26 < rcurtin> what is observations[0]? is that your full training sequence?

22:26 < rcurtin> that first emission you printed looks fine... are the second and third emission distributions roughly the same?

22:27 < cult-> observations are the full training seq yes

22:29 < cult-> this is after Train() -> http://pastebin.com/eJJ4CEyC

22:29 < cult-> in order: initial, transition, emission mean, emission covariance

22:30 < cult-> so maybe the training with hmm(3, gaussiandistribution(2)) didn't work?

22:30 < rcurtin> yeah, but you have 3 different emission distributions, one for each class

22:30 < rcurtin> can you also print hmm.Emission()[1] and hmm.Emission()[2]?

22:30 < cult-> sure, one moment

22:30 < rcurtin> thanks

22:32 < cult-> http://pastebin.com/a9VdmDKu

22:33 < rcurtin> hmmm, I wonder if the optimization starting from a uniform matrix is causing the problem

22:33 < rcurtin> can you try adding this before Train():

22:33 < rcurtin> arma::mat c = arma::randu<arma::mat>(3, 3);

22:34 < rcurtin> for (size_t i = 0; i < 3; ++i)

22:34 < rcurtin> c.row(i) /= arma::accu(c.row(i));

22:34 < rcurtin> hmm.Train() = c;

22:35 < cult-> hmm.Train() = c;

22:35 < rcurtin> ack, sorry, change all the calls to .row() with .col()

22:35 < rcurtin> ah, sorry! hmm.Transition() = c

22:35 < rcurtin> typing faster than I am thinking :)

22:35 < cult-> ok

22:36 < rcurtin> it looks to me like your training set consists of three pretty separated gaussians

22:36 < rcurtin> but for some reason the training code is not picking up on that, and the optimization is failing with a perfectly uniform transition matrix

22:37 < cult-> true

22:37 < cult-> and it worked

22:38 < cult-> i show the output once again

22:38 < cult-> http://pastebin.com/tsvKzHpC

22:39 < cult-> so they are identical expect that the hmm.Emission()[0] hmm.Emission()[1] are swapped

22:40 < cult-> rcurtin: thank you very much for your help!

22:40 < rcurtin> I'm happy to help

22:40 < cult-> i will try this with real data and see if i still need the hack

22:40 < rcurtin> I put a lot of time into that HMM implementation back many years ago, I am very happy to see it used :)

22:40 < cult-> well

22:40 < rcurtin> I think that what I should do is change the initialization of the transition and initial matrices

22:41 < cult-> i am hesitating between ghmm and mlpack for hmm

22:41 < cult-> by the way it would be nice to have EM beside baum-welch for training

22:41 < rcurtin> I agree, that would be a nice thing

22:41 < rcurtin> ghmm is quite old, is it still maintained?

22:42 < rcurtin> I used to use HTK many years ago for speech HMMs but that library has died (actually it was already dead when I was using it in 2007!)

22:42 < cult-> i don't know, but with your community and help i see a good chance on picking mlpack ;)

22:42 < rcurtin> if you like you can open a bug on github asking for EM support for HMMs, and maybe someone will come along and do it

22:42 < cult-> awesome

22:42 < rcurtin> currently my mlpack time is pretty backlogged, but maybe someday I might get around to it... :)

22:43 < cult-> it will be used very well, i will be back soon

22:43 < cult-> good night and thanks!