Ejemplo n.º 1
0
    def __init__(self, shape, probc, meanc, varc,name=None,\
        var_axes=(0,),mean_fix=None,var_fix=None,\
        is_complex=False,map_est=False,zvarmin=1e-3, tune_gmm=False):

        # Save properties
        self.map_est = map_est
        self.is_complex = is_complex
        self.zvarmin = zvarmin
        self.tune_gmm = tune_gmm
        self.mean_fix = mean_fix
        self.var_fix = var_fix

        dtype = meanc.dtype
        BaseEst.__init__(self,shape=shape,var_axes=var_axes,dtype=dtype,\
            name=name, type_name='GMM', nvars=1, cost_avail=True)

        # If the GMM parameters are given, set them now
        self.mix = None
        self.set_gmm_param(probc, meanc, varc)
        self.it = 0

        # Set the indicators on which the variance and means are fixed
        if self.mean_fix is None:
            self.mean_fix = np.zeros(len(probc))
        if self.var_fix is None:
            self.var_fix = np.zeros(len(probc))
Ejemplo n.º 2
0
    def __init__(self,shape,var_axes=(0,),max_it=10, step_init=1,\
        dtype=np.float64,name=None,\
        step_max=1,step_min=1e-8,zinit=None,is_complex=False,gtol=1e-3):

        BaseEst.__init__(self,shape=shape,var_axes=var_axes,dtype=dtype,\
            name=name, type_name='ScalarNL', nvars=1, cost_avail=True)

        # Save parameters
        self.max_it = max_it
        self.cost_avail = True
        self.step_last = step_init
        self.step_max = step_max
        self.step_min = step_min
        self.is_complex = is_complex
        self.gtol = gtol
        self.min_it = 1

        # Set default value that the Hessian is available
        self.hess_avail = True

        # Set initial point
        if (zinit is None):
            self.zlast = self.proj(np.zeros(self.shape))
        else:
            self.zlast = zinit
Ejemplo n.º 3
0
 def __init__(self, zmean, zvar, shape,name=None,\
              var_axes = (0,), zmean_axes='all',\
              is_complex=False, map_est=False, tune_zvar=False,\
              tune_rvar=False):
             
     if np.isscalar(shape):
         shape = (shape,)
     if is_complex:
         dtype = np.double
     else:
         dtype = np.complex
          
     BaseEst.__init__(self,shape=shape,dtype=dtype,name=name,
                      var_axes=var_axes,type_name='GaussEst', cost_avail=True)
     self.zmean = zmean
     self.zvar = zvar
     self.cost_avail = True  
     self.is_complex = is_complex  
     self.map_est = map_est         
     self.zmean_axes = zmean_axes
     self.tune_zvar = tune_zvar
     self.tune_rvar = tune_rvar
     
     ndim = len(self.shape)
     if self.zmean_axes == 'all':
         self.zmean_axes = tuple(range(ndim))
         
     # If zvar is a scalar, then repeat it to the required shape,
     # which are all the dimensions not being averaged over
     if np.isscalar(self.zvar):
         var_shape = get_var_shape(self.shape, self.var_axes)
         self.zvar = np.tile(self.zvar, var_shape) 
Ejemplo n.º 4
0
 def __init__(self, zval, pz, shape, var_axes=(0,),\
              is_complex=False,name=None):
                              
     if np.isscalar(shape):
         shape = (shape,)
     # Convert scalars to arrays
     if np.isscalar(zval):
         zval = np.array([zval])
     if not is_complex and np.any(zval.imag != 0):
         import warnings
         warnings.warn('zval is complex, but is_complex is False (forcing True)')
         is_complex = True
     if np.isscalar(pz):
         pz = np.array([pz])
         
     # Set parameters of base estimator
     dtype = zval.dtype
     BaseEst.__init__(self,shape=shape, var_axes=var_axes, dtype=dtype, name=name,\
         type_name='DiscreteEst', nvars=1, cost_avail=True)
                     
     # Set parameters
     self.zval = zval
     self.pz = pz
     self.shape = shape
     self.is_complex = is_complex
     self.fz = -np.log(pz)
Ejemplo n.º 5
0
    def __init__(self,y,shape,var_axes=(0,),thresh=0,perr=1e-6,\
                 name=None,var_init=np.Inf,dtype=np.float64):

        BaseEst.__init__(self, shape=shape, var_axes=var_axes, dtype=dtype,\
            name=name,type_name='BinaryQuantEst', nvars=1, cost_avail=True)
        self.y = y
        self.shape = shape
        self.thresh = thresh
        self.perr = perr
        self.cost_avail = True
        self.var_init = var_init
Ejemplo n.º 6
0
    def __init__(self,A,y,wvar=0,\
                 wrep_axes='all', var_axes=(0,),name=None,map_est=False,\
                 is_complex=False,rvar_init=1e5,tune_wvar=False):

        BaseEst.__init__(self, shape=A.shape0, var_axes=var_axes,\
            dtype=A.dtype0, name=name,\
            type_name='LinEstim', nvars=1, cost_avail=True)
        self.A = A
        self.y = y
        self.wvar = wvar
        self.map_est = map_est
        self.is_complex = is_complex
        self.cost_avail = True
        self.rvar_init = rvar_init
        self.tune_wvar = tune_wvar

        # Get the input and output shape
        self.zshape = A.shape0
        self.yshape = A.shape1

        # Set the repetition axes
        ndim = len(self.yshape)
        if wrep_axes == 'all':
            wrep_axes = tuple(range(ndim))
        self.wrep_axes = wrep_axes

        # Compute the SVD terms
        # Take an SVD A=USV'.  Then write p = SV'z + w,
        if not A.svd_avail:
            raise common.VpException("Transform must support an SVD")
        self.p = A.UsvdH(y)
        srep_axes = A.get_svd_diag()[2]

        # Compute the norm of ||y-UU*(y)||^2/wvar
        if np.all(self.wvar > 0):
            yp = A.Usvd(self.p)
            wvar1 = common.repeat_axes(wvar,
                                       self.yshape,
                                       self.wrep_axes,
                                       rep=False)
            err = np.abs(y - yp)**2
            self.ypnorm = np.sum(err / wvar1)
        else:
            self.ypnorm = 0

        # Check that all axes on which A operates are repeated
        for i in range(ndim):
            if not (i in self.wrep_axes) and not (i in srep_axes):
                raise common.VpException(
                    "Variance must be constant over output axis")
            if not (i in self.var_axes) and not (i in srep_axes):
                raise common.VpException(
                    "Variance must be constant over input axis")
Ejemplo n.º 7
0
    def __init__(self,
                 shape,
                 var_axes=[(0, ), (0, )],
                 name=None,
                 map_est=False):
        self.map_est = map_est

        # Initial variances
        self.zvar0_init = np.Inf
        self.zvar1_init = np.Inf

        nvars = 2
        dtype = np.float64
        BaseEst.__init__(self,shape=[shape,shape], var_axes=var_axes, dtype=dtype, name=name,\
            type_name='ReLUEst', nvars=nvars, cost_avail=True)
Ejemplo n.º 8
0
    def __init__(self,A,b,wvar=0,var_axes=[(0,), (0,)], wrep_axes='all',\
                 name=None,map_est=False,is_complex=False,est_meth='svd',\
                 nit_cg=100, atol_cg=1e-3, save_stats=False):

        self.A = A
        self.b = b
        self.wvar = wvar
        self.map_est = map_est
        self.is_complex = is_complex
        self.cost_avail = True

        # Initial variance.  This is large value since the quantities
        # are underdetermined
        self.zvar0_init = np.Inf
        self.zvar1_init = np.Inf

        # Set parameters of the base estimator
        shape = [A.shape0, A.shape1]
        dtype = [A.dtype0, A.dtype1]
        nvars = 2
        for i in range(nvars):
            if var_axes[i] == 'all':
                ndim = len(shape[i])
                var_axes[i] = tuple(range(ndim))
        if wrep_axes == 'all':
            ndim = len(shape[1])
            wrep_axes = tuple(range(ndim))
        self.wrep_axes = wrep_axes

        BaseEst.__init__(self,shape=shape, var_axes=var_axes, dtype=dtype, name=name,\
            type_name='LinEstTwo', nvars=nvars, cost_avail=True)

        # Initialization depending on the estimation method
        self.est_meth = est_meth
        if self.est_meth == 'svd':
            self.init_svd()
        elif self.est_meth == 'cg':
            self.init_cg()
        else:
            raise common.VpException(
                "Unknown estimation method {0:s}".format(est_meth))

        # CG parameters
        self.nit_cg = nit_cg
        self.atol_cg = atol_cg
        self.save_stats = save_stats
        self.init_hist_dict()
Ejemplo n.º 9
0
    def __init__(self, est_list, name=None):

        # Save estimator list
        self.est_list = est_list

        # Get parameters from the estimators
        shape = []
        var_axes = []
        dtype = []
        cost_avail = True
        nvars = len(est_list)
        for est in est_list:
            shape.append(est.shape)
            var_axes.append(est.var_axes)
            dtype.append(est.dtype)
            cost_avail = cost_avail and est.cost_avail
        self.cost_avail = cost_avail
        BaseEst.__init__(self,shape=shape,var_axes=shape,dtype=dtype,\
            name=name, type_name='StackEst', nvars=nvars, cost_avail=cost_avail)
Ejemplo n.º 10
0
 def __init__(self, zval, pz, shape, var_axes=(0,),\
              is_complex=False,name=None):
                              
     # Convert scalars to arrays
     if np.isscalar(zval):
         zval = np.array([zval])
     if np.isscalar(pz):
         pz = np.array([pz])
         
     # Set parameters of base estimator
     dtype = zval.dtype
     BaseEst.__init__(self,shape=shape, var_axes=var_axes, dtype=dtype, name=name,\
         type_name='DiscreteEst', nvars=1, cost_avail=True)
                     
     # Set parameters
     self.zval = zval
     self.pz = pz
     self.shape = shape
     self.is_complex = is_complex
     self.fz = -np.log(pz)
Ejemplo n.º 11
0
    def __init__(self, est_list, w, name=None):

        self.est_list = est_list
        self.w = w

        shape = est_list[0].shape
        var_axes = est_list[0].var_axes
        dtype = est_list[0].dtype

        # Check that all estimators have cost available
        for est in est_list:
            if est.shape != shape:
                raise common.VpException('Estimators must have the same shape')
            if est.var_axes != var_axes:
                raise common.VpException(
                    'Estimators must have the same var_axes')
            if not est.cost_avail:
                raise common.VpException(\
                    "Estimators in a mixture distribution"+\
                    "must have cost_avail==True")
        BaseEst.__init__(self,shape=shape,var_axes=var_axes,dtype=dtype,\
            name=name, type_name='Mixture', nvars=1, cost_avail=True)