Basit's Review

[BasitJaved]

Hi Boris and Cris,

Thank you for this opportunity and I am very excited to work with you on this algorithm.

I likes the comparison with CNN especially the part where it was mentioned that unlike CNN which lose image information, this algorithm cross-comparisons and clustering are far more complex and will contain all the information, although this is exciting but I believe it will also increase training times exponentially as this is what I have observed in case of CNNs.
I also like the different approach compared to SGD, as unlike SGD which tries to minimize error this new technique tries to maximize the similarities, since SGD does perform well in some use cases would love to compare the results of this new technique with SGD.
As for the code I tried to find the simplest example to read from Github repository which I feel was line_pattrens.py
Below I will try to explain what I believe code is doing in this file

Class Cdert and CP are basically tuples that we use to append list dert_ and P_, In cross_comp and form_PM_

In cross_comp(image)
Get shape of Image (h, w)
Initialize dictionary frame_of_patterns_=[]
Loop over the h to compare the pixcels in rows (y = 1, y = height)(y is row)
Pixel = dictionary frame_of_patterns_[y, :] (pixcels of row y)
Initialize dictionary dert_
Take first 2 pixcels 1stpixcel, 2ndpixcel = Pixel[0:2]
Take Difference_of_piscels _d= 2ndpixcel - 1stpixcel
m = avg – abs(Difference_of_pixcel)
Append dert(Cdert(1stpixcel, Difference_of_pixcel = 0, m=(_m + _m / 2))
Loop over all next pixcels (p is new pixcel, _p is old pixcel)
take Difference_of_piscels d= 2ndpixcel - 1stpixcel

m = avg – abs(Difference_of_pixcel)
we set avg = 15 and we are taking abs value of difference of pixels to know magnitude of difference, so m will be positive when there is little to no difference between 2 pixels like pixels that belong to same objects and it will be negative when difference between pixels is large like when there is sudden change in brightness of pixels e.g, edge of an object.
Append dert_(Cdert(old pixcel, Difference_of_pixcel = _d,( oldDifferenceofpixcel) m=(m + _m ))
Update p = p, d = d, m = m (old values to new values)
Append dert(Cdert(p, Difference_of_pixcel = d, m=(m + m / 2))
Q: Why is first and last m = (m0 + m0 / 2) while inbetween it is m = m_new + m
old
Pass the list dert to from_Pm and store in Pm
Pm is a list of tuples of CP containing sign, L, I, D, M, dert, sub_layers, (dertP, smP for line PPs)
If length of Pm is more then 4:
Compute the adjacent Ms by from_adjecent_M and store them in adj_M
Evaluate sub-recursion in each Pm

Append frame_of_pattrens_ with Pm_

	Return frame_of_pattrens_

In from_Pm(P_dert_) (P_dert_ is actually dirt_ list)
Initializing P_ list
save first dirt_[0] in dert_
from dirt_[0], get values for sign, D, L, I, M, dert, sub_H
all these values are for CP that we initialize at top
loop over remaining P_dert_
if sign changes
append P_ with CP tuple
reset L, I, D, M, dert_, sub_H to 0
accumulate all CP parameters
append P_ with CP tuple
return P_

in from_adjacent_M_(Pm_):
pri_M = take M values from fist tuple in list of Pm_
M = take M values from second tuple in list of Pm_
Create a list of adj_M_ and store first value as abs(M values from second tuple in list of Pm_)
Loop over the remaining list of Pm_:
Next_M = Pm.M (2,3,4,5,6,…..)
Append adj_M_ with (abs(pri_M / 2) + abs(next_M / 2))
Update pri_M to M
Update M to Next_M
Append adj_M_ with pri_M (last project)
Return adj_M_

Above is what I understood from code and there can be mistakes which I would love to discuss.
My area of interest is object detection and object tracking so I would love to see how this technique change/improve those areas of computer vision and how I will impact the industries especially areas like self-driving cars, assisted vision for blind people, its use in agriculture (weed detection, plant health detection, detection of fruits and their condition), its use in manufacturing industry and so on.

[boris-kz]

Thanks Basit!

Re training, it's basically fitting in ANN and all statistical approaches. We don't have that, our feedback adjusts filters / hyperparameters, but there are no individual weights per pixel to fit.

Re information loss, we will have graceful degradation on higher levels, after comparison and evaluation per pattern. Basically, evaluation drives clustering, which forms a more coarse representation, while discrete details are pushed down the compositional hierarchy. That hierarchy will be mapped to physical memory hierarchy: from registers to tape. So, the details may not be totally lost, but they become harder to access.

Re comparing performance with CNN, it can't be done because this algorithm is far from complete.
I will respond to code questions latter.

[boris-kz]

Your notes on code are mostly correct, although I wouldn't call classes "tuples".
So the next step would be getting into 2nd level of 1D alg: line_PPs_draft, which is a work in progress.
Or you can get into 2D alg, see wiki for workflow: https://github.com/boris-kz/CogAlg/wiki