Understanding the process

[marat200073]

Hi, Boris.
I am Marat, who was introduced by Mr. Chris. I have read CogAlg several times and tried to understand.
When line_1D_alg.py was executed, it showed me execution time, not anything else. I am not sure how it works.
Furthermore, I hope you let me know what I do to run frame_2D_alg. There are many main.
Of course, I understand what CogAlg does. and it is very interesting to me.
Thanks.

[lasred]

Hi Marat

Thank you for your interest. It may be helpful to take a look at Boris's most recent comments/suggestions on this post - #55 where his recommendation was to start with line_patterns

[marat200073]

Thanks. I will.

[marat200073]

[lasred]

This was Boris's response on the other post

'Ok great. So, the first thing is to understand line_patterns, it's the most basic code.
I know you already run it, but did you see the output patterns?

It's best to do in Pycharm: set init_y = 500 and put a breakpoint in line 80 because you only need to process one row in the image, that's why it's 1D. Then step to the next row and Pycharm variables tab in debug window will show P_: a row of patterns formed by processing previous row of pixels. Then you can unfold P_ into individual Ps, and each P into multiple levels of variables, sequentially.
BTW, Pycharm has very powerful breakpoints, just right-click on one and you can type any sort of code in the window, as a condition.

We also have discussion groups on Skype, I can add you to them, just connect with me: boris.kazachenko'

Were you able to debug through and see the output patterns?

[marat200073]

[boris-kz]

They represent kernel-level derivatives in dert: p,d, m, summed in Ps and then used as criteria for further processing.

[boris-kz]

Hi, Boris.
I am Marat, who was introduced by Mr. Chris. I have read CogAlg several times and tried to understand.
When line_1D_alg.py was executed, it showed me execution time, not anything else. I am not sure how it works.
Furthermore, I hope you let me know what I do to run frame_2D_alg. There are many main.
Of course, I understand what CogAlg does. and it is very interesting to me.
Thanks.

Great, appreciate your interest Marat!
So, line_patterns is best understood by running it in Pycharm debug window and checking Variables tub.
Same for frame_blobs, but please wait till I push some fixes tonight.

Also see related, discussion: #59, I will probably merge them.

[boris-kz]

Sorry, @marat200073, I am moving this into "running the code" discussion.

[marat200073]

Thanks. I have seen this in "running the code" discussion. no problem.
Mr.Chris asked me that I would ask you about the next assignment.
I hope you let me know the next assignment.
Best Regards

[boris-kz]

Thanks Marat, the first step is always understanding line_patterns, that's the most basic code. Or you can go through Readme and discuss here if you prefer theory first.

[alex-pitertsev]

Hi, Boris.
I would like to thank you for the possibility to discuss this new approach to machine learning.
I am sorry if my questions seem amateur, but I would like to start with the idea from the very beginning. I have read the article, comments, and questions made by others, try to run the code in the simplest variant as I think (1D processing) but still do not obtain a clear understanding of the math below this approach.
1). The article says that existing approaches still start with weighted summation per parameter, which degrades the input before any comparison and evaluation. As far as I understand, it talks about the convolution operation, which is one of the main operations in training convolutional neural networks.
This operation actually performs an irreversible transformation with the loss of some information. It is believed that this allows you to select the main part of it for the formation of a feature map, and thus reduce the number of input parameters to a reasonable limit according to the capabilities of modern computers.
So, due to convolution and some other operations in the classical approach, we lose more and more information about the input image in the learning process.
Does the proposed approach save more input information after transforming from one step to another? Are proposed information transformation operations reversible? If not, it would be good to estimate the quantitative conversion loss in the proposed method in comparison with classical to make a conclusion about the advantages of the proposed method.

[alex-pitertsev]

2.) I assume that the transformations of the input information given in the code are particular implementations of some abstract mathematical operations. The article explains about atomic inputs (I understand it as brightness level of pixels in case of gray image) and output symbolic data is merely a product of their encoding by some cognitive process. I would like to have a list of examples and constraints to understand, what math operation could be treated here as a cognitive process and what couldn't.

[boris-kz]

Thanks Alex!

Very broadly, I define cognitive as clustering based on lateral recognition: match, which is a product of cross-comparison. All transformations beyond the very first step are selective. That means main part here is logic, the math is broken-up into such small pieces that it doesn't warrant math notation.

That logic of cross-comparison and clustering is best expressed in code, and the simplest version is line_patterns. Please see "Running the code discussion", but the code should be traceable without running. Although you will have to memorize a lot of variables, sorry.

[boris-kz]

"Lateral" and "cross" means that comparison is among inputs within a sample (such as image), not between sample and and template. This is very similar to cross-correlation, which is the essence of convolution. The difference in my approach is in specific operations and resulting output variables: symbols. And also in that there are no individual weights per pixel, or training that forms them.

[marat200073]

Hi, Boris.
Let me explain my understanding and opinion on line_pattern.py.
I think it seems like the light spectrum. As you know, visible light passing through a prism is classified into 7 light wavelengths. Each wavelength has its own unique band. This is similar to how a line of an image passed through the black box, which is the engine, is classified into clusters. The basis is here on how to proceed with clustering. I think your method based on average value is very basic and essential. Simple is best. Moreover, it is better to make the difference between clusters based on the average value and its sign. I am not sure my understanding is right.
In my opinion, the curious thing is to choose the initial average value, as Haris mentioned. It is static in line_pattern.py, but I wonder if this will work well in real-time. I would like to perform equalization on the row, which is similar to histogram equalization if possible.
Moreover, recursive is expressed as 'sub', but I think this is merging. Clusters are included pixels in a gradual way.
The next thing that I couldn't understand is "rdn + 1 + 1 / Ls" in intra_Pm function and why a cluster contains more than 4 pixels.

I think your algorithm is unique and basic. I hope I will contribute to developing your idea as much as possible.
Thanks.

[boris-kz]

Thanks Marat! Ave is static now only because the code to update it is not finished, please see my reply to Alex below.

rdn + 1 + 1 / Ls" in intra_Pm: this represents redundancy of higher nesting levels to already existing lower levels (redundant representations of the same inputs). This redundancy is a cost function. + 1 because we add a new level, + 1/Ls because Ls = len(sub_Pm_).

[alex-pitertsev]

Thank you for your answers, Boris and Marat.
It seems a little clearer. Let me explain my idea. I asked about mathematics not in order to complicate your project, but on the contrary, make some generalizations and clearance. I believe that a new method that is positioned as an alternative to Deep Learning approach deserves a broad discussion like a scientific article or something else. It would be great to try to express even those small logic operations realized in the code by simple math notations or graphs. It would permit us to estimate how this particular implementation in python code close to the initial general idea of the Cognitive Algorithm. To answer the questions whether the same logic could be realized in a more simple way or how to make it work faster? There are some moments in the code now like setting initial values for a range of variables, those look like magic. And for me at the moment is unclear, if those setting would be working in the same manner for another input data? Or do they have optimal values for current data, although the code works?
I could try to make such a generalization on the basis of the current code if you consider my idea useful.
Thanks.

[boris-kz]

Alex, those constants are what I call filters and they are supposed to be adjusted by feedback from higher levels. Line_patterns is only the first level of 1D alg. They are constant here because we don't have functional higher levels yet, 2nd level line_PPs_draft is not finished. Please see last post here for more discussion on feedback: #59.

Re math and generalization, I don't see how the idea can be expressed any simpler than in the "outline of my approach", then fleshed-out in latter parts and the code. If you can do it, great, let me know.
I understand you point about math notation, it seems almost everyone is asking for it, but I simply don't see how it's better (or even close to as good) than Python. If you can show me, great, I am all ears.