self.with_label="default" if (self.negative_data): neg,negaddr=self.negative_data.next() nld=eval("self.negative_data.labeling_"+self.with_label)() ld=eval("self.model_node.get_curdb().labeling_"+self.with_label)() #print ld #print self.model_node #print self.model_node.get_curaddr #print self.model_node.get_curaddr() #print ld[self.model_node.get_curaddr()] label=self.label_op( ld[self.model_node.get_curaddr()] ) if (x.ndim==1): pycvf_warning("Your data is one dimensional only\n") pycvf_warning("Learning gonna be slow !\n") x=x.reshape(-1,1) label=[label] elif (x.ndim>2): pycvf_error("Your data is too high dimensional for learning\n") self.statmodel.train(x, label , online=True, *self.args, **self.kwargs ) Model=pycvf_model_class(None,None)(ModelTrainer) __call__=Model
# -*- coding: utf-8 -*- ######################################################################################################################################### # # MyModel By Bertrand NOUVEL # 2009 CNRS Postdoctorate JFLI # # (c) All rights reserved # ############################################### # ################################################################################################################################################################################ # Includes ################################################################################################################################################################################ import numpy from pycvf.core import genericmodel from pycvf.datatypes import image from pycvf.lib.graphics import rescale Model=genericmodel.pycvf_model_class(image.Datatype,image.Datatype)(rescale.Rescaler2d) __call__=Model
self.negative_data=negative_data if (self.negative_data!=None): self.negative_data=iter(self.negative_data) def set_model_node(self,model): self.model_node=model def on_model_destroy(self,model): self.model_node=None def process(self,x): #neg=numpy.array(map(lambda x:x[0],self.negative_data.next())) neg=self.negative_data.next()[0] if (x.ndim==1): pycvf_warning("Your data is one dimensional only\n") pycvf_warning("Learning gonna be slow !\n") x=x.reshape(-1,1) elif (x.ndim>2): pycvf_error("Your data is too high dimensional for learning\n") if (neg.ndim==1): pycvf_warning("Your data is one dimensional only\n") pycvf_warning("Learning gonna be slow !\n") neg=neg.reshape(-1,1) elif (neg.ndim>2): pycvf_error("Your data is too high dimensional for learning\n") self.statmodel.train(x,neg,online=False,*self.args,**self.kwargs) adata=numpy.vstack([x,neg]) aclass=self.statmodel.test(adata) rclass=[0]*x.shape[0]+[1]*neg.shape[0] return multiplicity(zip(numpy.sign(aclass),rclass)) Model=pycvf_model_class(basics.NumericArray.Datatype,basics.Label.Datatype)(ModelTrainer) __call__=Model
from pycvf.datatypes import basics class ModelIdxQuery(object): """ This model does query for nearest neighbors in an already build databases for queries The input is a set of query vectors / query elements and the output are there nearest neighbors in our database. """ def __init__(self,idxclass,k=10,*args, **kwargs): self.idx=(pycvf_builder(idxclass) if type(idxclass) in [str, unicode] else idxclass) self.args=args self.kwargs=kwargs self.k=k self.model_node=None def set_model_node(self,model): self.model_node=model def on_model_destroy(self,model): self.model_node=None def process(self,x): if (x.ndim==1): x=x.reshape(-1,1) label=[label] elif (x.ndim>2): pycvf_error("Your data is too high dimensional for querying\n") return self.idx.getitem(x,self.k) Model=pycvf_model_class(basics.NumericArray.Datatype,basics.NumericArray.Datatype)(ModelIdxQuery) __call__=Model
######################################################################################################################################### # # MyModel By Bertrand NOUVEL # 2009 CNRS Postdoctorate JFLI # # (c) All rights reserved # ############################################### # ################################################################################################################################################################################ # Includes ################################################################################################################################################################################ ### ### import sys from pycvf.core import genericmodel from pycvf.core.errors import * class Writer: def __init__(self,stream=sys.stderr,sep="\n"): self.stream=stream self.sep=sep def process(self,x): self.stream.write(repr(x)+self.sep) return x Model=genericmodel.pycvf_model_class(None,None)(Writer) __call__=Model
class ImageSaver(object): def __init__(self, filename="img-$n.png", label_op=None, *args, **kwargs): self.c = 0 self.filename = filename self.args = args self.kwargs = kwargs self.mdl = None if label_op == None: label_op = lambda x: x self.label_op = label_op self.model_node = None def set_model_node(self, model): self.model_node = model def on_model_destroy(self, model): self.model_node = None def process(self, x): filename = self.filename.replace("$n", "%08d" % (self.c,)) filename = filename.replace("$address", "%r" % (self.label_op(self.model_node.get_curaddr()),)) NumPy2PIL(x).save(filename, *self.args, **self.kwargs) self.c += 1 return x Model = pycvf_model_class(image.Datatype, image.Datatype)(ImageSaver) __call__ = Model
from pycvf.datatypes import basics from pycvf.datatypes import image import zopencv class Contour: def __init__(self, *args, **kwargs): self.model_node = None def set_model_node(self, model): self.model_node = model while self.model_node.parent != None: self.model_node = self.model_node.parent def on_model_destroy(self, model): self.model_node = None def process(self, points): srcb = self.model_node.context["thesrc"]["src"].copy("C") length = len(points) for x in range(length - 1): src_point = zopencv.cvPoint(points[x, 0], points[x, 1]) dst_point = zopencv.cvPoint(points[x + 1, 0], points[x + 1, 1]) color = zopencv.cvScalar(255, 0, 0, 0) zopencv.cvLine(srcb, src_point, dst_point, color, 1, 8, 0) return srcb Model = genericmodel.pycvf_model_class(basics.Label.Datatype, image.Datatype)(Contour) __call__ = Model
def init(self): self.filename=self.directory+"/randomprojection.npy" try: if (self.reset): raise Exception self.rpmat=numpy.load(self.filename) if (self.rpmat==None): raise Exception self.model_node.status=genericmodel.STATUS_READY pycvf_debug(10, "loaded"+ self.filename+"...") except: self.rpmat=None def set_model_node(self,model): self.model_node=model self.directory=model.get_directory() self.init() def on_model_destroy(self,model): self.model_node=None def process(self,v): if (self.rpmat==None): self.rpmat=(numpy.random.random((self.odim,(v.shape[1] if v.ndim==2 else v.shape[0])))-.5)*2 numpy.save(self.filename,self.rpmat) self.model_node.status=genericmodel.STATUS_READY x=numpy.dot(self.rpmat,numpy.asmatrix(v).T).T #print x.shape return x Model=genericmodel.pycvf_model_class(None,basics.NumericVector.Datatype)(RandomProjection) __call__=Model
######################################################################################################################################### # # MyModel By Bertrand NOUVEL # 2009 CNRS Postdoctorate JFLI # # (c) All rights reserved # ############################################### import numpy, sys from pycvf.core import genericmodel from pycvf.datatypes import basics class Reference: """ This is use to make reference to other elements in the pipeline""" def __init__(self,node='src'): self.node=node self.model_node=None def set_model_node(self,model): self.model_node=model while (self.model_node.parent!=None): self.model_node=self.model_node.parent def on_model_destroy(self,model): self.model_node=None def process(self,points): return self.model_node.context['thesrc'][self.node] Model=genericmodel.pycvf_model_class(None,None)(Reference) __call__=Model
def is_prefix(a,b): return (b[:len(a)]==a) class Summarizer: """ This agglomerates all the outputs of a node""" def __init__(self): self.model_node=None self.model_node_info=None def set_model_node(self,model): self.model_node=model self.model_root_node=model while self.model_root_node.parent!=None: self.model_root_node=self.model_root_node.parent def on_model_destroy(self,model): self.model_node=None self.model_root_node=None def process(self,points): if self.model_node_info==None: self.metas=self.model_node.parent.get_features_meta() d=[ [mm[0]] for mm in self.metas.items() ] names=reduce(lambda b,n:b+[n[0]],d,[]) nd=filter(lambda x: (("/"+self.model_node.name+"/") not in x[0][0]) and (len(filter(lambda t:is_prefix(x[0][0], t),names ))==1) ,zip(d,range(len(d)))) self.model_node_info=nd print nd return map( lambda x: self.model_root_node.context['thesrc'][self.metas[x[0][0]]['processline']],self.model_node_info ) Model=genericmodel.pycvf_model_class(None,None)(Summarizer) __call__=Model
#return x #def init_model(self,mdl,id="",*args,**kwargs): #mdl.init('/',self.datatype_in) #def xmap(l): #return map(lambda e:emdl.process(e),l) #self.processline='src|map'+id #self.context['map'+id]=xmap class ModelMap: def __init__(self,mdl,modelelementpath=-1,*args, **kwargs): self.mdl=mdl self.modelelementpath=modelelementpath self.modelelementpathno=0 def set_model_node(self,model): self.model_node=model self.mdl.init('/',self.model_node.datatype_in, self.model_node) #self.model.metainf_curdb=None def on_model_destroy(self,model): self.mdl=None self.model_node=None metak= self.mdl.get_features_meta().keys() try: self.modelelementpathno=metak.index(modelelementpath) except: self.modelelementpathno=modelelementpath def process(self,l): return map(lambda e:self.mdl.process(e)[self.modelelementpathno],l) Model=genericmodel.pycvf_model_class(None,None)(ModelMap) __call__=Model
# (c) All rights reserved # ############################################### # ################################################################################################################################################################################ # Includes ################################################################################################################################################################################ import numpy, sys import pywt from pycvf.core import genericmodel from pycvf.datatypes import image from pycvf.datatypes import list as ldt def idwt_one_layer(x,wav): return pywt.idwt2(x,wav) class Imgidwt: def __init__(self,wavelet='db5'): if (not wavelet in pywt.wavelist()): print pywt.wavelist() self.wavelet=wavelet def process(self,x): r=map(lambda y:idwt_one_layer(y,self.wavelet),x) return numpy.dstack(r) Model=genericmodel.pycvf_model_class( ldt.Datatype(ldt.Datatype(image.Datatype)),image.Datatype)(Imgidwt) __call__=Model
class Ngrams: def __init__(self,size=2): self.size=size self.lst=[] def process(self,origiter): class XIter: def __init__(silf): pass def __iter__(silf): if (not hasattr(origiter,"next")) and (hasattr(origiter,"__iter__")): it=iter(origiter) else: it=origiter cont=True try: r=[] for x in range(self.size) : r.append( it.next()) yield r while True: r.pop(0) r.append( it.next()) yield r except StopIteration: pass return iter(XIter()) Model=pycvf_model_class(None,lambda x:generated.Datatype(x) )(Ngrams) __call__=Model
self.lm=None self.expr=expr self.centralized=centralized def process(self,x): if ((self.lm==None) or (self.lm.shape[0])!=x.shape[0]*x.shape[1]): if (not self.centralized): lm=numpy.mgrid[0:1:(1./x.shape[0]),0:1:(1./x.shape[1])] else: lm=numpy.mgrid[-.5:.5:(1./x.shape[0]),-.5:.5:(1./x.shape[1])] cmap=eval(self.expr,{'x':(lm[0]*1J+lm[1]),'numpy':numpy,'scipy':scipy}) if (not self.centralized): re=numpy.real(cmap)%1 im=numpy.imag(cmap)%1 else: re=(numpy.real(cmap)+.5)%1 im=(numpy.imag(cmap)+.5)%1 re*=x.shape[1] im*=x.shape[0] self.lm=numpy.dstack([im, re]).swapaxes(0,2).swapaxes(1,2) if (x.ndim==3): r=all_layer(lambda y :scipy.ndimage.map_coordinates(y,self.lm) ,x) else: r=scipy.ndimage.map_coordinates(x,self.lm) return r Model=genericmodel.pycvf_model_class(image.Datatype,image.Datatype)(map_coordinates) __call__=Model
import numpy, sys from pycvf.core import genericmodel from pycvf.datatypes import image from pycvf.datatypes import list as ldt from pycvf.nodes.image.pyramidalize import pyramidalize def focus_part(x,focuspoint=(0.5,0.5),szpart=(32,32)): h,w=x.shape[:2] by=int(h*focuspoint[1])-(szpart[1]//2) ey=by+szpart[1] bx=(w*focuspoint[0])-(szpart[0]//2) ex=bx+szpart[0] return x[by:ey,bx:ex] class Foveaizer: def __init__(self,*args, **kwargs): self.args=args self.kwargs=kwargs self.focus_point=(.5,.5) def process(self,x): r=map(lambda xi:focus_part(xi,self.focus_point), pyramidalize(x,*self.args,**self.kwargs)) return r Model=genericmodel.pycvf_model_class(image.Datatype,ldt.Datatype(image.Datatype))(Foveaizer) __call__=Model
*self.args, **self.kwargs ) my,mx=x.min(axis=0) MY,MX=x.max(axis=0) dy=MY-my+eps dx=MX-mx+eps mg=numpy.mgrid[:resy,:resx].swapaxes(0,2).swapaxes(0,1) #print mg mg=mg.reshape(-1,2) #print resy,resx mg*=numpy.array([[dx,dy]]) mg/=numpy.array([[resx,resy]]) mg+=numpy.array([[mx,my]]) testset=mg res=self.statmodel.test(testset) if (self.normalizemap): res-=res.min() res/=res.max() res*=255 #print res.shape res=res.reshape(resy,resx) res=res.T res=numpy.flipud(res) print "RESHAPE=",res.shape,res.dtype return res Model=pycvf_model_class(basics.NumericArray.Datatype, image.Datatype)(ModelTrainer) __call__=Model
from pycvf.datatypes import audio from pycvf.datatypes import histogram class Spectromemory(): def __init__(self,blocksize=60): self.blocksize=blocksize self.packetlist=[] def process(self,origiter): class XIter: def __init__(silf): pass def __iter__(silf): cont=True blk=0 try: r=[] for x in range(self.blocksize) : r.append( origiter.next()) yield r while True: r.pop(0) r.append( origiter.next()) yield r except StopIteration: pass return iter(XIter()) Model=pycvf_model_class(None,None)(Spectromemory) __call__=Model
import scipy #import hashlib from pycvf.core.errors import * from pycvf.core import genericmodel from pycvf.core import builders from pycvf.datatypes import basics from pycvf.lib.info.cacheable import NotReady ######################################################################################################################################### # Define our model ######################################################################################################################################### class DEModelProcessor(object): """ Here we reduce the dimension of set of points by using a density estimation model and by returning the parameters of this density estimation model. """ def __init__(self, modelmodule="pycvf.stat.DE.pyem_gmm", *args, ** kwargs): self.model=__import__(modelmodule,fromlist=modelmodule.split(".")[:-1]) self.args=args self.kwargs=kwargs self.modelpath=None def process(self,v): m=self.model.Model(*self.args, **self.kwargs) print v.shape m.train(v) return m.get_as_vector() Model=genericmodel.pycvf_model_class(None,basics.NumericVector.Datatype)(DEModelProcessor) __call__=Model
if (self.totrain): q=min(v.shape[0],self.totrain) self.totrain-=q self.ipca.add_train(v[:q]) if (self.totrain==0): self.ipca.recompute() self.save() if (v.shape[0]==q): self.model_node.status=genericmodel.STATUS_NOT_READY raise NotReady else: v=v[q:] try: assert(v.ndim==2) r=self.ipca.dimred(v) except KeyboardInterrupt: raise except Exception,e: print e self.model_node.status=genericmodel.STATUS_NOT_READY raise NotReady self.model_node.status=genericmodel.STATUS_READY return r def save(self): if (self.ipca) and (self.totrain==0): self.ipca.save(file(self.pcafilename,"w")) Model=genericmodel.pycvf_model_class(basics.NumericArray.Datatype,basics.NumericArray.Datatype)(IPCAProcessor) __call__=Model
from pycvf.nodes.image.pyramidalize import pyramidalize def focus_part_put(img,x,focuspoint=(0.5,0.5),szpart=(32,32)): h,w=img.shape[:2] by=max(0,int(h*focuspoint[1])-(szpart[1]//2)) ey=by+min(szpart[1],x.shape[1]) bx=max(0,(w*focuspoint[0])-(szpart[0]//2)) ex=bx+min(szpart[0],x.shape[0]) try: img[by:ey,bx:ex]=x except: pass return img def upscale(img): return img.repeat(2,axis=0).repeat(2,axis=1) class Unfoveaizer: def __init__(self,*args, **kwargs): self.args=args self.kwargs=kwargs self.focus_point=(.5,.5) def process(self,x): return reduce(lambda b,y:focus_part_put(upscale(b),y), x[1:] , x[0]) Model=genericmodel.pycvf_model_class(ldt.Datatype(image.Datatype),image.Datatype)(Unfoveaizer) __call__=Model