Merge branch 'master' of https://github.com/boris-kz/CogAlg

# Conflicts:
#	frame_2D_alg/agg_recursion.py
#	frame_2D_alg/comp_slice.py
#	frame_2D_alg/frame_blobs.py
#	frame_2D_alg/vect_edge.py

Author: kwcckw

frame_2D_alg/agg_recursion.py

@@ -311,26 +311,24 @@ def agg_H_par(focus):  # draft parallel level-updating pipeline
 
         frame.aggH = list(H)  # convert back to list
 
-def agg_H_seq(focus, image, _nestt=(1,0), _fb_={}, fb_={}):  # recursive level-forming pipeline, called from cluster_C_
-
-    fb_ = {}
-    if _fb_:  # if feedback's coefficients, update current ave
-        global ave, ave_L, icoef, max_dist       
-        ave *= _fb_['agg_recursion']  # for highest level, get feedback from prior agg_H?
-        ave_L *= _fb_['agg_recursion']
-        icoef *= _fb_['agg_recursion']
-        max_dist *= _fb_['agg_recursion']
-    fb_['vect_edge'] = (ave+ave_L+icoef+max_dist)/4  # feedback coefficient to the next vect_edge
-
-    frame = frame_blobs_root(focus, _fb_)
-    intra_blob_root(frame, _fb_, fb_)
-    vectorize_root(frame, _fb_, fb_)
+def agg_H_seq(focus, image, _nestt=(1,0), rave_=[]):  # recursive level-forming pipeline, called from cluster_C_
+    # draft:
+    global ave, ave_L, icoef, max_dist  # add derTT aves
+    if rave_:
+        ave_ = np.array([ave, ave_L, max_dist, icoef])  # mw_, dw_
+        ave, ave_L, max_dist, icoef = ave_ * rave_
+    else:
+        rave_ = np.append(np.ones(4), np.ones(4), np.ones(4))
+        # weight per ave?
+    frame = frame_blobs_root(focus, rave_2FB(rave_))
+    intra_blob_root(frame, rave_2IB(rave_))  # not sure
+    vectorize_root(frame, rave_2VR(rave_))
     if not frame.nnest:
         return frame
     comb_altG_(frame.node_[-1].node_, ave*2)  # PP graphs in frame.node_[2]
     # feedforward agg+
     cluster_C_(frame, rc=1)  # ave *= recursion count
-    rM,rD = 1,1  # sum derTT coefs: m_,d_ [M,D,n, I,G,gA, L,A] / Et,baseT,ext:
+    rM,rD = 1,1  # sum derTT coefs: m_,d_ [M,D,n,o I,G,A,L] / Et, baseT, dimension
     rV_t = np.ones((2,8))  # d value is borrowed from corresponding ms in proportion to d mag, both scaled by fb
     # feedback to scale m,d aves:
     for fd, nest,_nest,Q in zip((0,1), (frame.nnest,frame.lnest), _nestt, (frame.node_[2:],frame.link_[1:])):  # skip blob_,PP_,link_PP_
@@ -352,8 +350,7 @@ def agg_H_seq(focus, image, _nestt=(1,0), _fb_={}, fb_={}):  # recursive level-f
             y = y+dy; x = x+dx; Y = Y+dy; X = X+dx  # alter focus shape, also focus size: +/m-, res decay?
             if y > 0 and x > 0 and Y < image.shape[0] and X < image.shape[1]:  # focus is inside the image
                 # rerun agg+ with new bottom-level focus, aves:
-                fb_['agg_recursion'] = np.sum(rV_t)/16  #  feedback coefficient to the next agg_H (temporary use sum)        
-                agg_H_seq(image[y:Y,x:X], image, (frame.nnest,frame.lnest), _fb_=fb_)
+                agg_H_seq(image[y:Y,x:X], image, (frame.nnest,frame.lnest), rave_=rV_t)
 
     return frame
 

frame_2D_alg/comp_slice.py

@@ -64,7 +64,7 @@ def vectorize_root(frame, _fb_={}, fb_={}):
         mw_ *= _fb_['vect_edge']
         dw_ *= _fb_['vect_edge']
     fb_['slice_edge'] = (ave+ave_d+ave_G+ave_PPm+ave_PPd+ave_L+ave_dI+sum(mw_)+sum(dw_))/23  # feedback coefficient to the next slice_edge
-    
+
     blob_ = unpack_blob_(frame)
     for blob in blob_:
         if not blob.sign and blob.G > ave_G * blob.root.olp:

frame_2D_alg/frame_blobs.py

@@ -186,12 +186,12 @@ def __init__(rnode_, blob):
         rnode_.rng = blob.root.rng + 1
 
 def intra_blob_root(frame, _fb_={}, fb_={}):
-    
+
     if _fb_:  # update ave based on feedback coefficients
         global aveR
         aveR *= _fb_['intra_blob']  # get feedback coefficient from slice_edge
     fb_['frame_blobs'] = aveR  # feedback coefficient to the next frame_blobs
-    
+
     frame.olp = frame.rng = 1
     for blob in frame.blob_:
         rblob(blob)

frame_2D_alg/vect_edge.py

@@ -38,10 +38,8 @@
 capitalized variables are usually summed small-case variables
 '''
 
-# module-specific:
 ave, ave_d, ave_rn, ave_ro, ave_G, ave_L, max_dist, icoef, med_cost, ave_dI, mw_, dw_ = 5, 10, 2, 2, 100, 1, 2, 0.15, 10, 20, np.ones(8), np.ones(8)
 
-
 class CLay(CBase):  # flat layer if derivation hierarchy
     name = "lay"
     def __init__(l, **kwargs):
@@ -50,7 +48,6 @@ def __init__(l, **kwargs):
         l.root = kwargs.get('root', None)  # higher node or link
         l.node_ = kwargs.get('node_', [])  # concat across fork tree
         l.link_ = kwargs.get('link_', [])
-        l.baseT = kwargs.get('baseT', np.zeros(5))
         l.derTT = kwargs.get('derTT', np.zeros((2,8)))  # m_,d_ [M,D,n,o, I,G,A,L], sum across fork tree,
         # add weights for cross-similarity, along with vertical aves, for both m_ and d_?
         # altL = CLay from comp altG
@@ -112,7 +109,7 @@ def __init__(G,  **kwargs):
         G.Et = kwargs.get('Et', np.zeros(4))  # sum all params M,D,n,o
         G.yx = kwargs.get('yx', np.zeros(2))  # init PP.yx = [(y+Y)/2,(x,X)/2], then ave node yx
         G.box = kwargs.get('box', np.array([np.inf,-np.inf,np.inf,-np.inf]))  # y,Y,x,X, area: (Y-y)*(X-x)
-        G.baseT = kwargs.get('baseT',np.zeros(5))  # I,G,Dy,Dx,L  # L=box
+        G.baseT = kwargs.get('baseT',np.zeros(4))  # I,G,Dy,Dx  # from slice_edge
         G.derTT = kwargs.get('derTT',np.zeros((2,8)))  # m,d / Et,baseT: [M,D,n,o, I,G,A,L], summed across derH lay forks
         G.derTTe = kwargs.get('derTTe',np.zeros((2,8)))  # sum across link.derHs
         G.derH = kwargs.get('derH',[])  # each lay is [m,d]: Clay(Et,node_,link_,derTT), sum|concat links across fork tree
@@ -151,42 +148,33 @@ class CL(CBase):  # link or edge, a product of comparison between two nodes or l
     def __init__(l,  **kwargs):
         super().__init__()
         l.nodet = kwargs.get('nodet',[])  # e_ in kernels, else replaces _node,node: not used in kernels
+        l.L = 0  # distance between nodes
         l.Et = kwargs.get('Et', np.zeros(4))
         l.fd = kwargs.get('fd',0)
         l.yx = kwargs.get('yx', np.zeros(2))  # [(y+Y)/2,(x,X)/2], from nodet
-        l.baseT = kwargs.get('baseT', np.zeros(5))
+        l.baseT = kwargs.get('baseT', np.zeros(4))
         l.derTT = kwargs.get('derTT', np.zeros((2,8)))  # m_,d_ [M,D,n,o, I,G,A,L], sum across derH
         l.derH  = kwargs.get('derH', [])  # list of single-fork CLays
-        l.box = kwargs.get('box', np.array([np.inf,-np.inf,np.inf,-np.inf]))  # y,Y,x,X, area: (Y-y)*(X-x)
         # add med, rimt, extH in der+
     def __bool__(l): return bool(l.nodet)
 
-def vectorize_root(frame, _fb_={}, fb_={}):  # init for agg+:
-
-    if _fb_:  # update ave based on feedback coefficients
-        global ave, ave_d, ave_rn, ave_ro, ave_G, ave_L, max_dist, icoef, med_cost, ave_dI, mw_, dw_
-        ave *= _fb_['agg_recursion']  # get feedback coefficient from comp_slice
-        ave_d *= _fb_['agg_recursion']
-        ave_rn *= _fb_['agg_recursion']
-        ave_ro *= _fb_['agg_recursion']
-        ave_G *= _fb_['agg_recursion']
-        ave_L *= _fb_['agg_recursion']
-        max_dist *= _fb_['agg_recursion']
-        icoef *= _fb_['agg_recursion']
-        med_cost *= _fb_['agg_recursion']
-        ave_dI *= _fb_['agg_recursion']
-        mw_ *= _fb_['agg_recursion']
-        dw_ *= _fb_['agg_recursion']
-    fb_['comp_slice'] = (ave+ave_d+ave_rn+ave_ro+ave_G+ave_L+max_dist+icoef+med_cost+ave_dI+sum(mw_)+sum(dw_))/26  # feedback coefficient to the next comp_slice
-    
+def vectorize_root(frame, rave_=[]):  # init for agg+:
+    # draft:
+    global ave, ave_d, ave_rn, ave_ro, ave_G, ave_L, max_dist, icoef, med_cost, ave_dI, mw_, dw_
+    if rave_:
+        ave_ = np.array([ave, ave_d, ave_rn, ave_ro, ave_G, ave_L, max_dist, icoef, med_cost, ave_dI, mw_, dw_])
+        ave, ave_d, ave_rn, ave_ro, ave_G, ave_L, max_dist, icoef, med_cost, ave_dI, mw_, dw_ = ave_ * rave_
+    else:
+        rave_ = np.append(np.ones(10), np.ones(10), np.ones(10))  # weight per ave?
     blob_ = unpack_blob_(frame)
     frame2G(frame, derH=[CLay(root=frame)], node_=[blob_], root=None)
     edge_ = []  # cluster, unpack
     for blob in blob_:
         if not blob.sign and blob.G > ave_G * blob.root.olp:
-            edge = slice_edge(blob, _fb_, fb_)
+            # convert rave_ to slice_edge coefs:
+            edge = slice_edge(blob, rave_2SE(rave_))
             if edge.G * (len(edge.P_)-1) > ave:  # eval PP
-                comp_slice(edge)
+                comp_slice(edge, rave_2CS(rave_))
                 if edge.Et[0] * (len(edge.node_)-1)*(edge.rng+1) > ave:
                     G_ = [PP2G(PP)for PP in edge.node_ if PP[-1][0] > ave]  # Et, no altGs
                     if len(G_) > ave_L:  # no comp node_,link_,PPd_
@@ -207,7 +195,9 @@ def vectorize_root(frame, _fb_={}, fb_={}):  # init for agg+:
         frame.link_ += [sum_G_(lG_)]; frame.lnest = 1
     frame.baseT = np.sum([G.baseT for G in PP_+ G_], axis=0)
     frame.derTT = np.sum([L.derTT for L in L_+ lG_], axis=0)
-    return frame
+
+    rave = []  # convert rave for comp_slice
+    return frame, rave
 
 def cluster_edge(iG_, frame):  # edge is CG but not a connectivity cluster, just a set of clusters in >ave G blob, unpack by default
 
@@ -372,13 +362,13 @@ def base_comp(_N, N, dir=1):  # comp Et, Box, baseT, derTT
     nM = M*rn; dM = _M - nM; mM = min(_M,nM) / max(_M,nM)
     nD = D*rn; dD = _D - nD; mD = min(_D,nD) / max(_D,nD)
     # comp baseT:
-    _I,_G,_Dy,_Dx,_L = _N.baseT; I,G,Dy,Dx,L = N.baseT   # I, G|D, angle, dimension
+    _I,_G,_Dy,_Dx = _N.baseT; I,G,Dy,Dx = N.baseT  # I, G|D, angle
     I *= rn; dI = _I - I; mI = abs(dI) / ave_dI
     G *= rn; dG = _G - G; mG = min(_G,G) / max(_G,G)
     mA, dA = comp_angle((_Dy,_Dx),(Dy*rn,Dx*rn))
-    L *= rn
     if N.fd:  # dimension is distance
-        mL, dL = min(_L,L)/ max(_L,L), _L - L
+        _L,L = _N.L, N.L
+        mL,dL = min(_L,L)/ max(_L,L), _L - L
     else:  # dimension is box area
         _y0,_x0,_yn,_xn =_N.box; _A = (_yn-_y0) * (_xn-_x0)
         y0, x0, yn, xn = N.box;   A = (yn - y0) * (xn - x0)
@@ -399,12 +389,12 @@ def comp_N(_N,N, ave, fd, angle=None, dist=None, dir=1):  # compare links, relat
     dderH = []
 
     [m_,d_], rn = base_comp(_N, N, dir)
-    baseT = np.array([(_N.baseT[0] +N.baseT[0]) /2, np.sum(d_* dw_), *angle, dist])
+    baseT = np.array([(_N.baseT[0] +N.baseT[0]) /2, np.sum(d_* dw_), *angle])
     derTT = np.array([m_, d_])
-    M = np.sum(m_*mw_); D = np.sum(np.abs(d_*dw_))  # feedback-weighted summation
+    M = np.sum(m_*mw_); D = np.sum(np.abs(d_*dw_))  # feedback-weighted sum
     Et = np.array([M,D, 8, (_N.Et[3]+N.Et[3]) /2])  # n comp vars, inherited olp
 
-    Link = CL(fd=fd, nodet=[_N,N], baseT=baseT, derTT=derTT, yx=np.add(_N.yx,N.yx)/2, box=extend_box(_N.box, N.box))
+    Link = CL(fd=fd, nodet=[_N,N], baseT=baseT, derTT=derTT, yx=np.add(_N.yx,N.yx)/2, L=dist)
     # spec / lay:
     if M > ave and (len(N.derH) > 2 or isinstance(N,CL)):  # else derH is redundant to dext,vert
         dderH = comp_H(_N.derH, N.derH, rn, Link, Et, fd)  # comp shared layers, if any
@@ -456,7 +446,7 @@ def sum2graph(root, grapht, fd, minL=0, maxL=None):  # sum node and link params
         else: N_ += [N]  # roots if minL
         N.root = graph
         yx_ += [N.yx]
-        graph.box = extend_box(graph.box, N.box)  # pre-compute graph.area += N.area?
+        graph.box = extend_box(graph.box, N.box)  # pre-compute graph.area += N.area? or from N.yx?
         graph.Et += N.Et * icoef  # deeper, lower weight
         if i and not fd: graph.baseT += N.baseT
         # not in CL
@@ -570,7 +560,7 @@ def blob2G(G, **kwargs):
     G.lnest = kwargs.get('lnest',0)  # link_H if > 0, link_[-1] is top L_
     G.derH = []  # sum from nodes, then append from feedback, maps to node_tree
     G.extH = []  # sum from rims
-    G.baseT = np.zeros(5)  # I,G,Dy,Dx
+    G.baseT = np.zeros(4)  # I,G,Dy,Dx
     G.derTT = kwargs.get('derTT', np.zeros((2,8)))  # m_,d_ base params
     G.derTTe = kwargs.get('derTTe', np.zeros((2,8)))
     G.box = kwargs.get('box', np.array([np.inf,np.inf,-np.inf,-np.inf]))  # y0,x0,yn,xn
@@ -584,8 +574,9 @@ def blob2G(G, **kwargs):
 def PP2G(PP):
     root, P_, link_, vert, latuple, A, S, box, yx, Et = PP
 
-    baseT = np.array((*latuple[:2], latuple[-2], *latuple[-1]))  # I,G,Dy,Dx,L
-    derTT = np.hstack((vert, np.zeros((2,2))))  # [I,G,A, M,D,L] -> [I,G,gA, M,D,n, empty L,A]
+    baseT = np.array((*latuple[:2], *latuple[-1]))  # I,G,Dy,Dx
+    [mI,mG,mA,mM,mD,mL], [dI,dG,dA,dM,dD,dL] = vert
+    derTT = np.array([np.array([mM,mD,mL,1,mI,mG,*mA,mL]), np.array([dM,dD,dL,1,dI,dG,*dA,dL])])
     y,x,Y,X = box; dy,dx = Y-y,X-x              # A = (dy,dx); L = np.hypot(dy,dx)
     G = CG(root=root, fd=0, Et=Et, node_=P_, link_=[], baseT=baseT, derTT=derTT, box=box, yx=yx, aRad=np.hypot(dy/2, dx/2),
            derH=[[CLay(node_=P_,link_=link_, derTT=deepcopy(derTT)), CLay()]])  # empty dfork