verne.freenode.net changed the topic of #mlpack to: http://www.mlpack.org/ -- We don't respond instantly... but we will respond. Give it a few minutes. Or hours. -- Channel logs: http://www.mlpack.org/irc/
kris1 has quit [Quit: kris1]
kris1 has joined #mlpack
< rcurtin>
zoq: ironstark: I'll go ahead and make sure that all the dependencies for r-base are installed on all 5 benchmarking systems
< partobs-mdp>
zoq: rcurtin: Could you take a look at HAM PR? I've got some problems T_T
< rcurtin>
partobs-mdp: sure, what would you like me to look at?
< rcurtin>
I am paying attention to a talk right now, but I think you can have my full attention in ~30m
< rcurtin>
ah sorry I see you made a github comment about it, I'll start there
< zoq>
partobs-mdp: Unfortunately, my time is limited right now ... can you make sure that the Linear parameter are correct inside the Linear class, e.g by printing the weight in the Forward step?
< partobs-mdp>
zoq: Checked - there indeed was garbage in Linear layer :) Fixed, now everything works - implementing the WRITE and SEARCH models.
< rcurtin>
partobs-mdp: you beat me to it, I found the same. the linear layer has N^2 + N elements, I guess you were only setting the first 2N
< rcurtin>
there is also a logical error after the JOIN operation: 'error: Mat::cols(): indices out of bounds or incorrectly used'
< rcurtin>
but you are probably aware of that
< rcurtin>
it happens later in the test, to be specific, not during the JOIN operation
< partobs-mdp>
rcurtin: Yes, I know - this code acts as a stub - working on it :)
< rcurtin>
sure, no problem, just making sure you knew about it
< rcurtin>
if compiled with -DDEBUG=OFF and -DPROFILE=OFF, those errors won't be displayed, Armadillo will just happily do something invalid and then suddenly you get a big backtrace and segfault :)
mikeling has joined #mlpack
partobs-mdp has quit [Remote host closed the connection]
< kris1>
Hi, zoq with the networkInit.hpp file when we intialise on per layer basis. The Parameter() function of the FFN module retrurns an matrix actually is this correct behaviour.
< kris1>
Or should i set the generator.Parameters() matrix to point to the parameters matrix after intialisation on per level basis.
partobs-mdp has joined #mlpack
< partobs-mdp>
zoq: rcurtin: I'm trying to implement forward pass of HAM, and I kind of know what to do, but I get huge error message. (Right now my goal is to port TreeMemory to LayerTypes - we won't need any other "callables" for it) Could someone take a look at the issue?
< partobs-mdp>
(The latest code is in the HAM PR on Github)
< rcurtin>
partobs-mdp: do you need to include mlpack/methods/ann/layer_types.hpp?
< partobs-mdp>
rcurtin: Got slightly confused - what file are we talking about?
< rcurtin>
in tree_memory.hpp, you have to include layer_types.hpp I believe
< rcurtin>
then you can't call Predict() directly on a LayerTypes, you have to use boost::visitor
< partobs-mdp>
rcurtin: Can we constrain even further on FFNs there?
< rcurtin>
I suppose it could be possible to use an FFN and not a LayerTypes... I'm not sure if that would add any extra trickiness for computing the gradients/etc.
< partobs-mdp>
rcurtin: Trickiness? Won't we immediately get all needed methods for doing that?
< rcurtin>
if we are learning the join/search/etc. functions, it might be tricky to properly propagate the gradients through it so that it learns
< rcurtin>
maybe it will work fine, I am not sure about that bit
< rcurtin>
but if you are not learning a join/search/etc. function at all but instead hardcoding it, then I think using FFN is fine
< partobs-mdp>
rcurtin: Well, we're doing DHAM - shouldn't it be just a chain-rule (backprop) learning?
< rcurtin>
right, and so the functions that FFN is giving us may not make it easy to have the FFN do only one step of learning
< rcurtin>
I am not 100% certain when I say that, so you should go ahead and try it, but I suspect there may be implementational difficulties later
< rcurtin>
partobs-mdp: I have to go to bed now, keep up the good work :)
< partobs-mdp>
rcurtin: Good night ^_^
< rcurtin>
I assume the most frustrating part is that a single little error yields like 100k lines of error messages
< rcurtin>
it's like unfair punishment
< rcurtin>
at least that's how I always feel when I can't get stuff to compile
< partobs-mdp>
rcurtin: I has 26k once, but it looks like that's not the absolute frustration record :)
< rcurtin>
even funnier when the types that gcc is putting out in its error messages are so large they can't even fit on my terminal...
< rcurtin>
I dunno, maybe 100k is an exaggeration... can't remember for sure
< rcurtin>
I dunno if lines in the best metric either---since some of the types are so long, counting them as '1 line' is a bit misleading
< partobs-mdp>
Well, it's down to 917 lines :)
< rcurtin>
what I have on your branch is only 438 lines but 4.7M characters
< rcurtin>
average > 1k characters per line
< rcurtin>
impressive :)
< rcurtin>
anyway, I am off to bed, I will check in again in the morning
witness has joined #mlpack
< kris1>
lozhnikov update the GAN PR. I have refactored the code and added another easier test.
< kris1>
I have done some preliminary checking that the matricies are being correctly instialised and updated.
< kris1>
The proble of small gradients still persists though the Gradients are in the order of 1e-5 and multiplying them by learning 1e-3 takes 1e-8 which can be considered as vanishing gradients.
< kris1>
Should i try clipping the gradients values. if yes what should be a reasonable clip value.
< lozhnikov>
kris1: In such a way you can set learningRate to 1.0
< kris1>
Hmmm let me check.
< kris1>
I will try to plot the images at diffrent iterations and check to see if the GAN is learning something or not.
mikeling has quit [Quit: Connection closed for inactivity]
kris1 has quit [Quit: kris1]
< zoq>
kris1: Sorry for the slow response; not sure I get your point, do you mean to call the Initalize method with a parameter matrix (not model.Parameters()) and afterwards we do model.Parameters() = parameters?
kris1 has joined #mlpack
partobs-mdp has quit [Remote host closed the connection]
< kris1>
I set the learning rate to around 0.5 still the gradients suffer from vanishing gradients problem. This network is only a 2 layer neural net. So i don’t understand why this is happening
< kris1>
Can you have a look at the code.
< kris1>
lozhnikov:
< lozhnikov>
kris1: I think there is no quick answer. I should spend some time debugging the code. I'll do that in the morning.
< kartik_>
at line 29 is where i want to copy the parameters to the network so that i can evaluate it and see the output of those parameters
< kartik_>
i knw im wrong. But what exactly should be done
< zoq>
kartik_: You can do function.parameters() = parameters;, you could also use answer = parameters; have you seen my last comment on the PR?
kartik__ has joined #mlpack
< kartik__>
yes <zoq> but i was still confused
< kartik__>
oh ohkae.. so as answer is given by the FFN itself
< kartik__>
modifying that will work as well
< kartik__>
also im thinking to make two optimizers .. one as optimizer
< zoq>
kartik__: Yes you can do both, since we call Optimize with function and function.Parameters
< zoq>
what's the purpose of the other optimizer?
< kartik__>
i was thinking if its possible to take the other optimizer give task and the input hidden and output layer size
kartik_ has quit [Ping timeout: 260 seconds]
< kartik__>
then it can make its own FFN model converge and test fitness using the task and then give output
< zoq>
But, in CNE we evaluate multiple 'networks' and merge the best ones, so we don't train a single network until it converges, maybe I missed something?
< kartik__>
CNE doesnt make species
< kartik__>
but neat does
< kartik__>
so ill be having multiple network parameter matrix
< kartik__>
and will test on the same model
< kartik__>
by setting different parameters
< kartik__>
<zoq> is it possible to just evaluate the FFN model on just one point without giving the train set and test set
< kartik__>
but just the parameters and the input ?
< zoq>
I was not talking about species I was talking about a population, as you pointed out you will have a bunch of network's/parameter; but you said you like to train a single network until it converges, which sounded strange since, if it converges we don't have to train another one.
< zoq>
You can use the Predict function instead of Evaluate.
< kartik__>
oh okhae.. thanks .. also <zoq> im confused about what to implement in the test case
< zoq>
I think we are talking about the same thing, but I don't get the second optimizer part.
< zoq>
We can just use the same test cases as you wrote for CMAES.
< kartik__>
the next optimizer takes the task and the model size of layers and then makes the population and uses the predict function to find the best parameter using fitness supplied by task as a template
< kartik__>
<zoq> is this correct
< kartik__>
then we will just have to supply a class of task type ..
< zoq>
If we use the current optimizer interface, the task is embedded inside the model itself, so Evaluate returns the Fitness of the model using the current parameter.
< zoq>
Based on the Fitness returns by Evaluate we can compare the different models.
< kartik__>
<zoq> sorry .. but i did not understand that
< kartik__>
the meaning of the task is embedded inside the network itself ?
< kartik__>
ohkae i got your point..
< zoq>
I was saying that we don't have to provide a task, since the task is to optimize the model. For example training a simple network on a dataset, the optimizer dosn't need to know what the task is or how the dataset looks like, since a call of Evaluate returns the fitness.
< zoq>
So, for me the code you provided looks just fine, what is left is to implement the reproduce function.
< kartik__>
<zoq> but there it was calculation using the train and test data points given to the model in .train() and here the task should be called to get the fitness.. how will optimize differentiate this ..
< zoq>
We don't have to differentiate between both, since fintess is nothing more as some kind of performance indicator we use to select the best model.
< zoq>
Let's say the task is to get 100% accuracy on a dataset, how do we get the fitness of a single model, we would go through each sample and evaluate the model right?
< kartik__>
right
< kartik__>
<zoq> exactly this is done .. the train and test data that is given before by calling Evaluate can be found for each dataset and the fitness can be found
< zoq>
So, I agree the number of tasks we can solve right now is limited to optimize a model to be good at classification, so we can't train it on some environment like Mario, but the step to get this done is minimal. I think we should concentrate on the classification task for now.
< kartik__>
okae
< kartik__>
<zoq> thanks a lot
< zoq>
Here to help, let me know if you need any help with the reproduce function.
witness has quit [Quit: Connection closed for inactivity]
< zoq>
kris1: Not sure you have seen my message.
< zoq>
kris1: Sorry for the slow response; not sure I get your point, do you mean to call the Initalize method with a parameter matrix (not model.Parameters()) and afterwards we do model.Parameters() = parameters?
< kris1>
I updated the PR. Have a look. Well that is what i am doing right now.
< zoq>
kris1: Ah, okay, I'll take a look once I get a chance.