You can subscribe to this list here.
2004 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}
(1) 
_{Sep}

_{Oct}

_{Nov}
(1) 
_{Dec}


2005 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}
(1) 
_{Jul}

_{Aug}

_{Sep}

_{Oct}
(2) 
_{Nov}

_{Dec}
(1) 
2006 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}
(3) 
_{Jun}
(1) 
_{Jul}
(3) 
_{Aug}
(8) 
_{Sep}

_{Oct}

_{Nov}

_{Dec}

2007 
_{Jan}
(1) 
_{Feb}

_{Mar}
(1) 
_{Apr}

_{May}
(2) 
_{Jun}
(3) 
_{Jul}
(1) 
_{Aug}
(4) 
_{Sep}
(15) 
_{Oct}
(4) 
_{Nov}

_{Dec}

2008 
_{Jan}
(10) 
_{Feb}
(2) 
_{Mar}

_{Apr}

_{May}
(7) 
_{Jun}
(4) 
_{Jul}
(6) 
_{Aug}
(12) 
_{Sep}

_{Oct}
(3) 
_{Nov}
(13) 
_{Dec}
(10) 
2009 
_{Jan}
(12) 
_{Feb}
(19) 
_{Mar}
(27) 
_{Apr}

_{May}
(6) 
_{Jun}
(9) 
_{Jul}

_{Aug}
(5) 
_{Sep}
(12) 
_{Oct}
(20) 
_{Nov}
(1) 
_{Dec}
(8) 
2010 
_{Jan}
(5) 
_{Feb}
(8) 
_{Mar}
(3) 
_{Apr}
(4) 
_{May}
(3) 
_{Jun}
(12) 
_{Jul}
(22) 
_{Aug}
(19) 
_{Sep}
(7) 
_{Oct}
(7) 
_{Nov}
(7) 
_{Dec}
(21) 
2011 
_{Jan}
(10) 
_{Feb}
(18) 
_{Mar}
(26) 
_{Apr}
(12) 
_{May}

_{Jun}
(3) 
_{Jul}
(6) 
_{Aug}
(11) 
_{Sep}
(19) 
_{Oct}
(32) 
_{Nov}
(31) 
_{Dec}
(27) 
2012 
_{Jan}
(8) 
_{Feb}
(5) 
_{Mar}
(19) 
_{Apr}
(3) 
_{May}
(3) 
_{Jun}
(14) 
_{Jul}
(15) 
_{Aug}
(3) 
_{Sep}
(14) 
_{Oct}
(7) 
_{Nov}
(6) 
_{Dec}
(36) 
2013 
_{Jan}
(18) 
_{Feb}
(8) 
_{Mar}
(22) 
_{Apr}
(4) 
_{May}
(18) 
_{Jun}
(16) 
_{Jul}
(9) 
_{Aug}
(8) 
_{Sep}
(4) 
_{Oct}
(6) 
_{Nov}
(1) 
_{Dec}
(3) 
2014 
_{Jan}
(5) 
_{Feb}
(3) 
_{Mar}
(5) 
_{Apr}
(6) 
_{May}
(2) 
_{Jun}

_{Jul}
(4) 
_{Aug}
(4) 
_{Sep}
(7) 
_{Oct}
(3) 
_{Nov}
(5) 
_{Dec}
(3) 
2015 
_{Jan}
(1) 
_{Feb}

_{Mar}

_{Apr}
(1) 
_{May}
(2) 
_{Jun}

_{Jul}
(3) 
_{Aug}
(4) 
_{Sep}

_{Oct}
(5) 
_{Nov}

_{Dec}

2016 
_{Jan}
(11) 
_{Feb}
(7) 
_{Mar}
(1) 
_{Apr}
(1) 
_{May}
(4) 
_{Jun}
(3) 
_{Jul}
(6) 
_{Aug}
(1) 
_{Sep}
(1) 
_{Oct}
(1) 
_{Nov}
(5) 
_{Dec}

2017 
_{Jan}
(6) 
_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 






1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22
(1) 
23

24
(1) 
25
(1) 
26

27
(1) 
28
(4) 


From: Tiziano Zito <tiziano.zito@bc...>  20130228 18:37:56

> This is relevant documentation on using fastica in mdp I could find: > > "... Observations of the same variable are stored on rows, different > variables are stored on columns. ..." > > I am having trouble understanding how the fastica input arguments should > be constructed? It says variables are stored in rows, and from the second > part I infer that measurements are stored in columns. I understand this as > one row  one variable, one column  one measurement. Well, actually exactly the opposite is implied here. Let's call x, y, z, your variables  in other words the pixels of an hypothetical 3 pixel image. Let's call x1, x2, x3, x4 different observations (measurements) of variable x, i.e. x1 is the grey value of pixel 'x' in image number 1, etc... The input data 2D matrix X to MDP should look like this: x1 y1 z1 X = x2 y2 z2 x3 y3 z3 x4 y4 z4 So, in Python notation:  X[:,0] gives you all raws corresponding to column 0, i.e. all observations of pixel 'x': x1, x2, x3, x4, etc...  X[0:,] gives you al columns corresponding to raw 0, i.e. all variables corresponding to observation number 1, in other words it gives you image number 1: x1, y1, z1. Is it now a bit more clear? The fact that your images are originally 2D doesn't change anything, just flatten the image before. So, if the image originally is 10x10 pixel, one image corresponds to a 1D array of size 100. You can then pile up several flattened images to build the input array X. Ciao, Tiziano 
From: Martin Savc <martin.savc@gm...>  20130228 14:54:23

This is relevant documentation on using fastica in mdp I could find: "... Observations of the same variable are stored on rows, different variables are stored on columns. ..." I am having trouble understanding how the fastica input arguments should be constructed? It says variables are stored in rows, and from the second part I infer that measurements are stored in columns. I understand this as one row  one variable, one column  one measurement. In my case images are stored in rows and columns hold the different measurements of a certain pixel position. But my interpretation is, each image is a measurement, and each pixel position is a variable. This is in conflict with my understanding of the documentation. Does signal processing use a different terminology that I am not aware of? Regards, Martin On 28 February 2013 08:44, Martin Savc <martin.savc@...> wrote: > Dear Pietro, > > I took a look at mdp source code and redid the experiment and you were > correct. I am not sure, what I did wrong the first time. Thank you for your > help. > > > Regards, > Martin > > > On 25 February 2013 16:26, Martin Savc <martin.savc@...> wrote: > >> Hi Pietro. >> >> Thanks for the reply. I do have some issues with your answer to work out, >> if you would be wiling to help me further. >> >> Using the format of data you suggested, lets say we supply a 20000x1024 >> matrix, and use white_comp=256, the FastICA metod will return a matrix >> shaped 20000x256, using considerably less memory in ~100Mb range. >> >> If I mark the vector of my flattened input image with 'I[k]', and use 'A' >> for independent image components (or mixing weight matrix) and 's[k]' for >> their coefficients (or independent components) then the generative model >> using numpy notation is: 'I[k]= A.dot(s[k].T)'. The index 'k' marks one of >> the flattened images. >> >> The naming conventions here seem to be somewhat confusing. The book names >> columns of the matrix 'A' the independent components (these are not >> dependent on the input image) and names 's' their coresponding >> coefficients. Blind Signal Separation literature seems to name the 's' >> values independent components and 'A' a mixing matrix. In any case, in our >> example the matrix 'A' should have a shape of 1024x256, the vector 's[k]' >> has a lenght of 256, and the image sample vector 'I[k]' a length of 1024. >> Given the data matrix is 20000x1024, the coresponding 'S' matrix contaning >> all vectors 's' would be 20000x256. The matrices may need be transposed, >> but the shape constraints still apply. >> >> This would mean, that the FastICA method either returns the component >> coefficients 'S'  given your input, or independent component matrix 'A'  >> given my original input with heavy memory usage. interpreting the method >> output as matrix S I inverted it to compute the matrix A as: >> 'A = numpy.linalg.pinv(S).dot(data)', >> where data is my input data matrix. The results where quite >> unsatisfactory, nothing like the features 'A' presented in the book. >> >> I also tried took a further look at the documentation for the fastica() >> shortcut method. It says: >> '... Observations of the same variable are stored on rows, different >> variables are stored on columns. ...' >> In my case, the image vectors 'I[k]' are measurements of different >> variables, whereas a particular location in the sample represents a single >> variable. Interpreting the documentation entry for fastica, I would expect >> that the rows would contain values from the same pixel  observations of >> the same variable, and columns would contain the flattened image vectors >> 'I[k]'. The final shape of the data matrix in our example here would then >> be 1024x20000. >> >> At this point I am unsure what the result of the FastICA node and fastica >> function is. I am also a bit unsure about the input arguments, as the >> documentation seems sparse ( :D ). I am also thinking of reading the cited >> article or read the MDP source code. Not sure which would be >> preferable/simpler. >> >> Bye, >> Martin >> >> > Hi Martin, >> > >> > you should put one image patch per row of your matrix, flattening the 32x32 >> > image into a 1024 elements vector. The final matrix should be 20000 x 1024. >> > That size could work, depending on the size of the RAM on your machine. To >> > make it smaller, you can declare the array with single precision, >> > dtype='float32'. >> > >> > I also believe that in the book they use PCA (they might call it whitening) >> > to reduce the dimensionality of the data. To reduce the dimensionality, set >> > the "white_comp" parameter of the FastICA node, as described in >> > http://mdptoolkit.sourceforge.net/api/mdp.nodes.FastICANodeclass.html#__init__. >> > For natural images, this corresponds in practice to a lowpass >> > filtering. >> > >> > Hope this helps, >> > Pietro >> > >> > >> > >> > On Fri, Feb 22, 2013 at 7:33 PM, Martin Savc <martin.savc@...> wrote: >> > >> >> Hi. >> >> >> >> I am having some trouble using the FastICA node. I'm trying to duplicate >> >> some of the results in the book http://www.naturalimagestatistics.net/ . >> >> For this I need use a large number of small image patches 32x32 pixels. >> >> Using 20000 patches, the data matrix size would be (32*32)x20000. In the >> >> book, the author uses 50000 image patches. But the MDP FastICA node memory >> >> footprint seems to grow exponentially relative to the number of image >> >> samples. Looking at the FastICA algorithm as presented in the book, I can't >> >> identify the reason for this relationship. Is it possible, the memory >> >> relation is due to some operation or is it inherent to the algorithm? Is >> >> there anything I can due to resolve this issue in MDP? >> >> >> >> Regards, >> >> Martin >> >> >> >> >> >>  >> >> Everyone hates slow websites. So do we. >> >> Make your web apps faster with AppDynamics >> >> Download AppDynamics Lite for free today: >> >> http://p.sf.net/sfu/appdyn_d2d_feb >> >> _______________________________________________ >> >> mdptoolkitusers mailing list >> >> mdptoolkitusers@... >> >> https://lists.sourceforge.net/lists/listinfo/mdptoolkitusers >> >> >> >> >> >> >> >> > 
From: Pietro Berkes <berkes@ga...>  20130228 08:23:11

Hi Martin, I didn't manage to reply in time. So did you find the issue? I'm 100% sure the input array should be 20000x1024, and in principle you should get the usual Gabor wavelets out of this exercise. Let me know if you have other issues with it. P. On Thu, Feb 28, 2013 at 7:44 AM, Martin Savc <martin.savc@...> wrote: > Dear Pietro, > > I took a look at mdp source code and redid the experiment and you were > correct. I am not sure, what I did wrong the first time. Thank you for your > help. > > > Regards, > Martin > > > On 25 February 2013 16:26, Martin Savc <martin.savc@...> wrote: > >> Hi Pietro. >> >> Thanks for the reply. I do have some issues with your answer to work out, >> if you would be wiling to help me further. >> >> Using the format of data you suggested, lets say we supply a 20000x1024 >> matrix, and use white_comp=256, the FastICA metod will return a matrix >> shaped 20000x256, using considerably less memory in ~100Mb range. >> >> If I mark the vector of my flattened input image with 'I[k]', and use 'A' >> for independent image components (or mixing weight matrix) and 's[k]' for >> their coefficients (or independent components) then the generative model >> using numpy notation is: 'I[k]= A.dot(s[k].T)'. The index 'k' marks one of >> the flattened images. >> >> The naming conventions here seem to be somewhat confusing. The book names >> columns of the matrix 'A' the independent components (these are not >> dependent on the input image) and names 's' their coresponding >> coefficients. Blind Signal Separation literature seems to name the 's' >> values independent components and 'A' a mixing matrix. In any case, in our >> example the matrix 'A' should have a shape of 1024x256, the vector 's[k]' >> has a lenght of 256, and the image sample vector 'I[k]' a length of 1024. >> Given the data matrix is 20000x1024, the coresponding 'S' matrix contaning >> all vectors 's' would be 20000x256. The matrices may need be transposed, >> but the shape constraints still apply. >> >> This would mean, that the FastICA method either returns the component >> coefficients 'S'  given your input, or independent component matrix 'A'  >> given my original input with heavy memory usage. interpreting the method >> output as matrix S I inverted it to compute the matrix A as: >> 'A = numpy.linalg.pinv(S).dot(data)', >> where data is my input data matrix. The results where quite >> unsatisfactory, nothing like the features 'A' presented in the book. >> >> I also tried took a further look at the documentation for the fastica() >> shortcut method. It says: >> '... Observations of the same variable are stored on rows, different >> variables are stored on columns. ...' >> In my case, the image vectors 'I[k]' are measurements of different >> variables, whereas a particular location in the sample represents a single >> variable. Interpreting the documentation entry for fastica, I would expect >> that the rows would contain values from the same pixel  observations of >> the same variable, and columns would contain the flattened image vectors >> 'I[k]'. The final shape of the data matrix in our example here would then >> be 1024x20000. >> >> At this point I am unsure what the result of the FastICA node and fastica >> function is. I am also a bit unsure about the input arguments, as the >> documentation seems sparse ( :D ). I am also thinking of reading the cited >> article or read the MDP source code. Not sure which would be >> preferable/simpler. >> >> Bye, >> Martin >> >> > Hi Martin, >> > >> > you should put one image patch per row of your matrix, flattening the 32x32 >> > image into a 1024 elements vector. The final matrix should be 20000 x 1024. >> > That size could work, depending on the size of the RAM on your machine. To >> > make it smaller, you can declare the array with single precision, >> > dtype='float32'. >> > >> > I also believe that in the book they use PCA (they might call it whitening) >> > to reduce the dimensionality of the data. To reduce the dimensionality, set >> > the "white_comp" parameter of the FastICA node, as described in >> > http://mdptoolkit.sourceforge.net/api/mdp.nodes.FastICANodeclass.html#__init__. >> > For natural images, this corresponds in practice to a lowpass >> > filtering. >> > >> > Hope this helps, >> > Pietro >> > >> > >> > >> > On Fri, Feb 22, 2013 at 7:33 PM, Martin Savc <martin.savc@...> wrote: >> > >> >> Hi. >> >> >> >> I am having some trouble using the FastICA node. I'm trying to duplicate >> >> some of the results in the book http://www.naturalimagestatistics.net/ . >> >> For this I need use a large number of small image patches 32x32 pixels. >> >> Using 20000 patches, the data matrix size would be (32*32)x20000. In the >> >> book, the author uses 50000 image patches. But the MDP FastICA node memory >> >> footprint seems to grow exponentially relative to the number of image >> >> samples. Looking at the FastICA algorithm as presented in the book, I can't >> >> identify the reason for this relationship. Is it possible, the memory >> >> relation is due to some operation or is it inherent to the algorithm? Is >> >> there anything I can due to resolve this issue in MDP? >> >> >> >> Regards, >> >> Martin >> >> >> >> >> >>  >> >> Everyone hates slow websites. So do we. >> >> Make your web apps faster with AppDynamics >> >> Download AppDynamics Lite for free today: >> >> http://p.sf.net/sfu/appdyn_d2d_feb >> >> _______________________________________________ >> >> mdptoolkitusers mailing list >> >> mdptoolkitusers@... >> >> https://lists.sourceforge.net/lists/listinfo/mdptoolkitusers >> >> >> >> >> >> >> >> > > >  > Everyone hates slow websites. So do we. > Make your web apps faster with AppDynamics > Download AppDynamics Lite for free today: > http://p.sf.net/sfu/appdyn_d2d_feb > _______________________________________________ > mdptoolkitusers mailing list > mdptoolkitusers@... > https://lists.sourceforge.net/lists/listinfo/mdptoolkitusers > > 
From: Martin Savc <martin.savc@gm...>  20130228 07:47:33

Dear Pietro, I took a look at mdp source code and redid the experiment and you were correct. I am not sure, what I did wrong the first time. Thank you for your help. Regards, Martin On 25 February 2013 16:26, Martin Savc <martin.savc@...> wrote: > Hi Pietro. > > Thanks for the reply. I do have some issues with your answer to work out, > if you would be wiling to help me further. > > Using the format of data you suggested, lets say we supply a 20000x1024 > matrix, and use white_comp=256, the FastICA metod will return a matrix > shaped 20000x256, using considerably less memory in ~100Mb range. > > If I mark the vector of my flattened input image with 'I[k]', and use 'A' > for independent image components (or mixing weight matrix) and 's[k]' for > their coefficients (or independent components) then the generative model > using numpy notation is: 'I[k]= A.dot(s[k].T)'. The index 'k' marks one of > the flattened images. > > The naming conventions here seem to be somewhat confusing. The book names > columns of the matrix 'A' the independent components (these are not > dependent on the input image) and names 's' their coresponding > coefficients. Blind Signal Separation literature seems to name the 's' > values independent components and 'A' a mixing matrix. In any case, in our > example the matrix 'A' should have a shape of 1024x256, the vector 's[k]' > has a lenght of 256, and the image sample vector 'I[k]' a length of 1024. > Given the data matrix is 20000x1024, the coresponding 'S' matrix contaning > all vectors 's' would be 20000x256. The matrices may need be transposed, > but the shape constraints still apply. > > This would mean, that the FastICA method either returns the component > coefficients 'S'  given your input, or independent component matrix 'A'  > given my original input with heavy memory usage. interpreting the method > output as matrix S I inverted it to compute the matrix A as: > 'A = numpy.linalg.pinv(S).dot(data)', > where data is my input data matrix. The results where quite > unsatisfactory, nothing like the features 'A' presented in the book. > > I also tried took a further look at the documentation for the fastica() > shortcut method. It says: > '... Observations of the same variable are stored on rows, different > variables are stored on columns. ...' > In my case, the image vectors 'I[k]' are measurements of different > variables, whereas a particular location in the sample represents a single > variable. Interpreting the documentation entry for fastica, I would expect > that the rows would contain values from the same pixel  observations of > the same variable, and columns would contain the flattened image vectors > 'I[k]'. The final shape of the data matrix in our example here would then > be 1024x20000. > > At this point I am unsure what the result of the FastICA node and fastica > function is. I am also a bit unsure about the input arguments, as the > documentation seems sparse ( :D ). I am also thinking of reading the cited > article or read the MDP source code. Not sure which would be > preferable/simpler. > > Bye, > Martin > > > Hi Martin, > > > > you should put one image patch per row of your matrix, flattening the 32x32 > > image into a 1024 elements vector. The final matrix should be 20000 x 1024. > > That size could work, depending on the size of the RAM on your machine. To > > make it smaller, you can declare the array with single precision, > > dtype='float32'. > > > > I also believe that in the book they use PCA (they might call it whitening) > > to reduce the dimensionality of the data. To reduce the dimensionality, set > > the "white_comp" parameter of the FastICA node, as described in > > http://mdptoolkit.sourceforge.net/api/mdp.nodes.FastICANodeclass.html#__init__. > > For natural images, this corresponds in practice to a lowpass > > filtering. > > > > Hope this helps, > > Pietro > > > > > > > > On Fri, Feb 22, 2013 at 7:33 PM, Martin Savc <martin.savc@...> wrote: > > > >> Hi. > >> > >> I am having some trouble using the FastICA node. I'm trying to duplicate > >> some of the results in the book http://www.naturalimagestatistics.net/ . > >> For this I need use a large number of small image patches 32x32 pixels. > >> Using 20000 patches, the data matrix size would be (32*32)x20000. In the > >> book, the author uses 50000 image patches. But the MDP FastICA node memory > >> footprint seems to grow exponentially relative to the number of image > >> samples. Looking at the FastICA algorithm as presented in the book, I can't > >> identify the reason for this relationship. Is it possible, the memory > >> relation is due to some operation or is it inherent to the algorithm? Is > >> there anything I can due to resolve this issue in MDP? > >> > >> Regards, > >> Martin > >> > >> > >>  > >> Everyone hates slow websites. So do we. > >> Make your web apps faster with AppDynamics > >> Download AppDynamics Lite for free today: > >> http://p.sf.net/sfu/appdyn_d2d_feb > >> _______________________________________________ > >> mdptoolkitusers mailing list > >> mdptoolkitusers@... > >> https://lists.sourceforge.net/lists/listinfo/mdptoolkitusers > >> > >> > > > > 
From: Mark Peterson <seo.yoursitesolution@gm...>  20130227 21:34:36

<p style="fontstyle:normal;fontweight:normal" lang="enAU"> <font color="#0000ff"><font face="Arial, sansserif"><font style="fontsize:11pt">Hello,</font></font></font></p> <p style="fontstyle:normal;fontweight:normal" lang="enAU"> <font color="#0000ff"><font face="Arial, sansserif"><font style="fontsize:11pt">Hope you are well. As part of our client research, we came across your website "MdpToolkit.sourceforge.net" and noticed your site is not ranking in the most important search engines like Google, Yahoo & Bing. I was wondering if you would be interested in search engine optimization services for your website at a very low cost.</font></font></font></p> <p style="fontstyle:normal;fontweight:normal" lang="enAU"> <font color="#0000ff"><font face="Arial, sansserif"><font style="fontsize:11pt">Proper search engine optimization will increase your brand recognition, web traffic and grow your sales, which is why you a web site to begin with right?</font></font></font></p> <p style="fontstyle:normal;fontweight:normal" lang="enAU"> <font color="#0000ff"><font face="Arial, sansserif"><font style="fontsize:11pt">We can promote your website to 1st page placement on Google, Yahoo, or Bing in three to six months guaranteed with our “National SEO” package. Three to six months is typical for all our SEO packages!</font></font></font></p> <p style="fontstyle:normal;fontweight:normal" lang="enAU"> <font color="#0000ff"><font face="Arial, sansserif"><font style="fontsize:11pt">So let me know if you would be interested or like me to mail you more details or schedule a call. We would love to work with you!</font></font></font></p> <p style="fontstyle:normal;fontweight:normal" lang="enAU"> <font color="#0000ff"><font face="Arial, sansserif"><font style="fontsize:11pt">I look forward to your reply.</font></font></font></p> <p style="fontstyle:normal;fontweight:normal" lang="enAU"> <font color="#0000ff"><font face="Arial, sansserif"><font style="fontsize:11pt">Sincerely,</font></font></font></p> <p style="fontstyle:normal;fontweight:normal" lang="enAU"> <font color="#0000ff"><font face="Arial, sansserif"><font style="fontsize:11pt">Mark Peterson</font></font></font></p> <p><font color="#0000ff"><font face="Arial, sansserif"><font style="fontsize:11pt"><span lang="enAU"><span style="fontstyle:normal"><span style="fontweight:normal">Business Development Manager</span></span></span></font></font></font></p> 
From: Martin Savc <martin.savc@gm...>  20130225 15:26:46

Hi Pietro. Thanks for the reply. I do have some issues with your answer to work out, if you would be wiling to help me further. Using the format of data you suggested, lets say we supply a 20000x1024 matrix, and use white_comp=256, the FastICA metod will return a matrix shaped 20000x256, using considerably less memory in ~100Mb range. If I mark the vector of my flattened input image with 'I[k]', and use 'A' for independent image components (or mixing weight matrix) and 's[k]' for their coefficients (or independent components) then the generative model using numpy notation is: 'I[k]= A.dot(s[k].T)'. The index 'k' marks one of the flattened images. The naming conventions here seem to be somewhat confusing. The book names columns of the matrix 'A' the independent components (these are not dependent on the input image) and names 's' their coresponding coefficients. Blind Signal Separation literature seems to name the 's' values independent components and 'A' a mixing matrix. In any case, in our example the matrix 'A' should have a shape of 1024x256, the vector 's[k]' has a lenght of 256, and the image sample vector 'I[k]' a length of 1024. Given the data matrix is 20000x1024, the coresponding 'S' matrix contaning all vectors 's' would be 20000x256. The matrices may need be transposed, but the shape constraints still apply. This would mean, that the FastICA method either returns the component coefficients 'S'  given your input, or independent component matrix 'A'  given my original input with heavy memory usage. interpreting the method output as matrix S I inverted it to compute the matrix A as: 'A = numpy.linalg.pinv(S).dot(data)', where data is my input data matrix. The results where quite unsatisfactory, nothing like the features 'A' presented in the book. I also tried took a further look at the documentation for the fastica() shortcut method. It says: '... Observations of the same variable are stored on rows, different variables are stored on columns. ...' In my case, the image vectors 'I[k]' are measurements of different variables, whereas a particular location in the sample represents a single variable. Interpreting the documentation entry for fastica, I would expect that the rows would contain values from the same pixel  observations of the same variable, and columns would contain the flattened image vectors 'I[k]'. The final shape of the data matrix in our example here would then be 1024x20000. At this point I am unsure what the result of the FastICA node and fastica function is. I am also a bit unsure about the input arguments, as the documentation seems sparse ( :D ). I am also thinking of reading the cited article or read the MDP source code. Not sure which would be preferable/simpler. Bye, Martin > Hi Martin, > > you should put one image patch per row of your matrix, flattening the 32x32 > image into a 1024 elements vector. The final matrix should be 20000 x 1024. > That size could work, depending on the size of the RAM on your machine. To > make it smaller, you can declare the array with single precision, > dtype='float32'. > > I also believe that in the book they use PCA (they might call it whitening) > to reduce the dimensionality of the data. To reduce the dimensionality, set > the "white_comp" parameter of the FastICA node, as described in > http://mdptoolkit.sourceforge.net/api/mdp.nodes.FastICANodeclass.html#__init__. > For natural images, this corresponds in practice to a lowpass > filtering. > > Hope this helps, > Pietro > > > > On Fri, Feb 22, 2013 at 7:33 PM, Martin Savc <martin.savc@...> wrote: > >> Hi. >> >> I am having some trouble using the FastICA node. I'm trying to duplicate >> some of the results in the book http://www.naturalimagestatistics.net/ . >> For this I need use a large number of small image patches 32x32 pixels. >> Using 20000 patches, the data matrix size would be (32*32)x20000. In the >> book, the author uses 50000 image patches. But the MDP FastICA node memory >> footprint seems to grow exponentially relative to the number of image >> samples. Looking at the FastICA algorithm as presented in the book, I can't >> identify the reason for this relationship. Is it possible, the memory >> relation is due to some operation or is it inherent to the algorithm? Is >> there anything I can due to resolve this issue in MDP? >> >> Regards, >> Martin >> >> >>  >> Everyone hates slow websites. So do we. >> Make your web apps faster with AppDynamics >> Download AppDynamics Lite for free today: >> http://p.sf.net/sfu/appdyn_d2d_feb >> _______________________________________________ >> mdptoolkitusers mailing list >> mdptoolkitusers@... >> https://lists.sourceforge.net/lists/listinfo/mdptoolkitusers >> >> 
From: Pietro Berkes <berkes@ga...>  20130224 15:14:46

Hi Martin, you should put one image patch per row of your matrix, flattening the 32x32 image into a 1024 elements vector. The final matrix should be 20000 x 1024. That size could work, depending on the size of the RAM on your machine. To make it smaller, you can declare the array with single precision, dtype='float32'. I also believe that in the book they use PCA (they might call it whitening) to reduce the dimensionality of the data. To reduce the dimensionality, set the "white_comp" parameter of the FastICA node, as described in http://mdptoolkit.sourceforge.net/api/mdp.nodes.FastICANodeclass.html#__init__. For natural images, this corresponds in practice to a lowpass filtering. Hope this helps, Pietro On Fri, Feb 22, 2013 at 7:33 PM, Martin Savc <martin.savc@...> wrote: > Hi. > > I am having some trouble using the FastICA node. I'm trying to duplicate > some of the results in the book http://www.naturalimagestatistics.net/ . > For this I need use a large number of small image patches 32x32 pixels. > Using 20000 patches, the data matrix size would be (32*32)x20000. In the > book, the author uses 50000 image patches. But the MDP FastICA node memory > footprint seems to grow exponentially relative to the number of image > samples. Looking at the FastICA algorithm as presented in the book, I can't > identify the reason for this relationship. Is it possible, the memory > relation is due to some operation or is it inherent to the algorithm? Is > there anything I can due to resolve this issue in MDP? > > Regards, > Martin > > >  > Everyone hates slow websites. So do we. > Make your web apps faster with AppDynamics > Download AppDynamics Lite for free today: > http://p.sf.net/sfu/appdyn_d2d_feb > _______________________________________________ > mdptoolkitusers mailing list > mdptoolkitusers@... > https://lists.sourceforge.net/lists/listinfo/mdptoolkitusers > > 
From: Martin Savc <martin.savc@gm...>  20130222 19:33:41

Hi. I am having some trouble using the FastICA node. I'm trying to duplicate some of the results in the book http://www.naturalimagestatistics.net/ . For this I need use a large number of small image patches 32x32 pixels. Using 20000 patches, the data matrix size would be (32*32)x20000. In the book, the author uses 50000 image patches. But the MDP FastICA node memory footprint seems to grow exponentially relative to the number of image samples. Looking at the FastICA algorithm as presented in the book, I can't identify the reason for this relationship. Is it possible, the memory relation is due to some operation or is it inherent to the algorithm? Is there anything I can due to resolve this issue in MDP? Regards, Martin 