示例#1
0
class ValueFunctionSpline:
    def __init__(self,X,y,k,sigma,beta):
        self.sigma = sigma
        self.beta = beta
        if sigma == 1.0:
            y = np.exp((1-beta)*y)
        else:
            y = ((1-beta)*(1.0-sigma)*y)**(1.0/(1.0-sigma))
        self.f = Spline(X,y,k)

    def fit(self,X,y,k):
        if self.sigma == 1.0:
            y = np.exp((1-self.beta)*y)
        else:
            y = ((1-self.beta)*(1.0-self.sigma)*y)**(1.0/(1.0-self.sigma))
        self.f.fit(X,y,k)

    def getCoeffs(self):
        return self.f.getCoeffs()

    def __call__(self,X,d = None):
        if d==None:
            if self.sigma == 1.0:
                return np.log(self.f(X,d))/(1-self.beta)
            else:
                return (self.f(X,d)**(1.0-self.sigma))/((1.0-self.sigma)*(1-self.beta))

        if sum(d)==1:
            return self.f(X)**(-self.sigma) * self.f(X,d)/(1-self.beta)
        raise Exception('Error: d must equal None or 1')
示例#2
0
class posterioDistriubtion(object):
    
    def __init__(self,p_d,pdf,d):
        self.mu = Spline(p_d,pdf,d)
        self.moments = {}
        
    def fit(self,p_d,pdf,d):
        self.mu.fit(p_d,pdf,d)
        
    def __call__(self,p_d):
        if isinstance(p_d,float) or len(p_d) ==1:
            return self.mu.feval1d(float(p_d))
        else:
            return self.mu(p_d)
            
    def getMoment(self,m):
        if not self.moments.has_key(m):
            if m == 1:
                self.moments[1] = quad(lambda p_d: p_d*self(p_d),0.0,1.0,full_output=1)[0]
            else:
                Ep_d = self.getMoment(1)
                mom = quad(lambda p_d: (p_d-Ep_d)**m*self(p_d),0.0,1.0,full_output=1)[0]
                if mom < 0:
                    self.moments[m] = -(-mom)**(1.0/m)
                else:
                    self.moments[m] = mom**(1.0/m)
        return self.moments[m]
    
    def getMoments(self,m = [1,2,3]):
        return np.array(map(self.getMoment,m))
示例#3
0
class posterioDistriubtion(object):
    def __init__(self, p_d, pdf, d):
        self.mu = Spline(p_d, pdf, d)
        self.moments = {}

    def fit(self, p_d, pdf, d):
        self.mu.fit(p_d, pdf, d)

    def __call__(self, p_d):
        if isinstance(p_d, float) or len(p_d) == 1:
            return self.mu.feval1d(float(p_d))
        else:
            return self.mu(p_d)

    def getMoment(self, m):
        if not self.moments.has_key(m):
            if m == 1:
                self.moments[1] = quad(lambda p_d: p_d * self(p_d),
                                       0.0,
                                       1.0,
                                       full_output=1)[0]
            else:
                Ep_d = self.getMoment(1)
                mom = quad(lambda p_d: (p_d - Ep_d)**m * self(p_d),
                           0.0,
                           1.0,
                           full_output=1)[0]
                if mom < 0:
                    self.moments[m] = -(-mom)**(1.0 / m)
                else:
                    self.moments[m] = mom**(1.0 / m)
        return self.moments[m]

    def getMoments(self, m=[1, 2, 3]):
        return np.array(map(self.getMoment, m))
示例#4
0
class ValueFunctionSpline:
    def __init__(self, X, y, k, sigma, beta):
        self.sigma = sigma
        self.beta = beta
        if sigma == 1.0:
            y = np.exp((1 - beta) * y)
        else:
            y = ((1 - beta) * (1.0 - sigma) * y)**(1.0 / (1.0 - sigma))
        self.f = Spline(X, y, k)

    def fit(self, X, y, k):
        if self.sigma == 1.0:
            y = np.exp((1 - self.beta) * y)
        else:
            y = ((1 - self.beta) * (1.0 - self.sigma) *
                 y)**(1.0 / (1.0 - self.sigma))
        self.f.fit(X, y, k)

    def getCoeffs(self):
        return self.f.getCoeffs()

    def __call__(self, X, d=None):
        if d == None:
            if self.sigma == 1.0:
                return np.log(self.f(X, d)) / (1 - self.beta)
            else:
                return (self.f(X, d)**(1.0 - self.sigma)) / (
                    (1.0 - self.sigma) * (1 - self.beta))

        if d == 1:
            return self.f(X)**(-self.sigma) * self.f(X, 1) / (1 - self.beta)
        raise Exception('Error: d must equal None or 1')