In [45]:

    

class LHS(object):

    def __init__(self,num,boundary,function=LHS.func):
        if function in [None,'']:
            self._function=func
        else:
            self._function=function
        self.num=num
        self.boundary=boundary

    @staticmethod
    def func(x):
        '''
        默认方法
        '''
        return x**2
    @property    
    def boundary(self):
        return self._boundary
    @boundary.setter
    def boundary(self,b):
        if not  b or type(b) !=list:
            raise ValueError('boundary must be a list')
        print 'aaa'
        self._boundary=b

    @property    
    def num(self):
        return self._num
    @num.setter
    def num(self,num):
        if not isinstance(num, int):
            raise ValueError('number must be an integer!')
        if num<0 or  num >1000:
            raise ValueError('score must between 0 ~ 1000!')
        self._num=num


    

In [3]:

    

import numpy as np


    

In [80]:

    

a=-10;b=10
x=(b - a) * np.random.random_sample((1,100)) + a
x.sort()


    

In [81]:

    

x=map(np.random.permutation,x)
x=np.array(x)


    

In [82]:

    

x=x[:,:10]
x.sort()


    

In [45]:

    

=x.shape


    

    




  File "<ipython-input-45-1551193f3852>", line 1
    (,j)=x.shape
     ^
SyntaxError: invalid syntax

In [39]:

    

len(x)


    

    
Out[39]:





1

In [41]:

    

x[:,1]


    

    
Out[41]:





array([-6.96446825])

In [99]:

    

import math
def distance(theta,p,xi,xj):
    s=0
    dim=len(xi)
    for d in range(dim):
        s+=theta[d]*pow(abs(xi[d]-xj[d]),p[d])
    return s
def corr(theta,p,xi,xj):
    return math.exp(-distance(theta,p,xi,xj))
def corrMartrix(x,theta,p):
    j=x.shape[1]
    CM=np.empty([j,j],dtype=np.float32)
    for m in range(j):
        for n in range(j):
            CM[m][n]=corr(theta,p,x[:,m],x[:,n])
    return np.asmatrix(CM)


    

In [75]:

    

a=corrMartrix(x,[1],[2])


    

In [52]:

    

CM=np.empty([j,j],dtype=float)


    

In [74]:

    

from numpy import linalg as LA


    

    




---------------------------------------------------------------------------
LinAlgError                               Traceback (most recent call last)
<ipython-input-74-2067a6dd2ebf> in <module>()
      1 from numpy import linalg as LA
----> 2 LA.inv(CM)

/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/numpy/linalg/linalg.pyc in inv(a)
    517     signature = 'D->D' if isComplexType(t) else 'd->d'
    518     extobj = get_linalg_error_extobj(_raise_linalgerror_singular)
--> 519     ainv = _umath_linalg.inv(a, signature=signature, extobj=extobj)
    520     return wrap(ainv.astype(result_t))
    521 

/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/numpy/linalg/linalg.pyc in _raise_linalgerror_singular(err, flag)
     88 
     89 def _raise_linalgerror_singular(err, flag):
---> 90     raise LinAlgError("Singular matrix")
     91 
     92 def _raise_linalgerror_nonposdef(err, flag):

LinAlgError: Singular matrix

In [77]:

    

a=np.asmatrix(a)


    

In [78]:

    

a.I


    

    
Out[78]:





matrix([[ -1937265.125     ,    -98036.1953125 ,  -3065854.25      , ...,
             33290.1328125 ,   -514630.375     , -21686724.        ],
        [   -98036.1875    ,  -7853673.        ,   3593809.5       , ...,
            763123.0625    ,  -9296311.        ,  -1066633.25      ],
        [ -3065854.25      ,   3593809.5       ,  -2096369.        , ...,
             97375.6875    ,  -1481651.625     ,  -1718462.75      ],
        ..., 
        [    33290.13671875,    763123.0625    ,     97375.7109375 , ...,
            411989.40625   ,  -1265667.375     ,    -69326.3125    ],
        [  -514630.4375    ,  -9296311.        ,  -1481651.75      , ...,
          -1265667.375     ,  18947168.        ,    832991.9375    ],
        [-21686724.        ,  -1066633.25      ,  -1718462.75      , ...,
            -69326.3203125 ,    832992.0625    , -14846957.        ]], dtype=float32)

In [89]:

    

sum(X*2)


    

    
Out[89]:





matrix([[-16.0617513 , -13.0363391 ,  -9.62624586,  -5.71061671,
          -1.35278714,  -1.16883422,   2.10991529,   6.55147332,
          17.7930863 ,  18.1579626 ]])

In [87]:

    

X=np.asmatrix(x)


    

In [91]:

    

One=np.matrix([1]*len(x))
One.T


    

    
Out[91]:





matrix([[1]])

In [127]:

    

def func(X):
    return sum(X**2)
def likelihood(x,theta,p):
    n=x.shape[1]
    y=func(x)
    Y=np.asmatrix(y).T
    X=np.asmatrix(x)
    OneT=np.matrix([1]*n)
    One=OneT.T
    C=corrMartrix(x,[1],[1])
    CI=C.I
    mu=OneT*CI*Y/(OneT*CI*One)
    sigma_2=((Y-One*mu).T*CI*(Y-One*mu))/n
    return mu,sigma_2


    

In [128]:

    

likelihood(x,[1],[1])


    

    
Out[128]:





(matrix([[ 31.25365068]]), matrix([[ 619.41367968]]))

In [126]:

    

n=x.shape[1]
y=func(x)
Y=np.asmatrix(y).T
X=np.asmatrix(x)
OneT=np.matrix([1]*n)
One=OneT.T
C=corrMartrix(x,[1],[1])
CI=C.I
mu=OneT*CI*Y/(OneT*CI*One)


    

In [130]:

    

math.sqrt(2)


    

    
Out[130]:





1.4142135623730951

In [133]:

    

PI=math.pi


    

In [198]:

    

n=X.shape[1]
y=func(X)
Y=np.asmatrix(y).T
OneT=np.matrix([1]*n)
One=OneT.T
C=corrMartrix(X,[1],[1])
CI=C.I
mu=OneT*CI*Y/(OneT*CI*One)
sigma_2=((Y-One*mu).T*CI*(Y-One*mu))/n
print 1.0/math.sqrt((2*PI*sigma_2)**n*LA.det(C))*math.exp(((Y-One*mu).T*CI*(Y-One*mu))/(-2*sigma_2))


    

    




0.0

In [199]:

    

LA.det(C)


    

    
Out[199]:





0.27207583

In [201]:

    

(2*PI*sigma_2)**n


    

    
Out[201]:





matrix([[  1.33148030e+34]])

In [202]:

    

((Y-One*mu).T*CI*(Y-One*mu))/(-2*sigma_2)


    

    
Out[202]:





matrix([[-5.]])

In [143]:

    

math.exp(((Y-One*mu).T*CI*(Y-One*mu))/-2*sigma_2)


    

    
Out[143]:





0.0

In [185]:

    

mu


    

    
Out[185]:





matrix([[ 37.29081987]])

In [182]:

    

sigma_2


    

    
Out[182]:





matrix([[ 237.0944424]])

In [181]:

    

y.mean()


    

    
Out[181]:





34.562408895858468

In [196]:

    

C.I


    

    
Out[196]:





matrix([[  2.40326285e+00,  -1.83641207e+00,  -3.33453265e-08, ...,
           5.55644889e-15,  -2.78751576e-15,  -9.42064009e-16],
        [ -1.83641207e+00,   2.57206297e+00,  -4.44177568e-01, ...,
          -8.43877157e-15,   3.99448287e-15,   6.08360556e-16],
        [ -3.33453265e-08,  -4.44177568e-01,   1.71519005e+00, ...,
           4.15611285e-14,  -3.88941029e-14,   2.44614158e-15],
        ..., 
        [  5.55644889e-15,  -8.43877157e-15,   4.15611285e-14, ...,
           1.49502859e+01,  -1.27745619e+01,   7.44865716e-08],
        [ -2.78751576e-15,   3.99448287e-15,  -3.88941029e-14, ...,
          -1.27745619e+01,   1.38369474e+01,  -9.26271737e-01],
        [ -9.42064009e-16,   6.08360556e-16,   2.44614158e-15, ...,
           7.44865787e-08,  -9.26271737e-01,   1.55260599e+00]], dtype=float32)

In [205]:

    

import pickle
def loadData(size,filename):
    with open(filename,'r') as f:
        x=pickle.load(f)
    map(np.random.permutation,x)
    sample=np.array(np.random.permutation(x)[:size])
    sample=sample[:,:size]
    sample.sort()
    return sample
def likelihood(x,theta,p):
    n=x.shape[1]
    y=func(x)
    Y=np.asmatrix(y).T
    OneT=np.matrix([1]*n)
    One=OneT.T
    C=corrMartrix(x,theta,p)
    CI=C.I
    mu=OneT*CI*Y/(OneT*CI*One)
    sigma_2=((Y-One*mu).T*CI*(Y-One*mu))/n
    return -1.0/math.sqrt((2*PI*sigma_2)**n*LA.det(C))*math.exp(((Y-One*mu).T*CI*(Y-One*mu))/(-2*sigma_2))


    

In [206]:

    

X=loadData(10,'haha.tl')


    

In [207]:

    

likelihood(X,[1],[1])


    

    
Out[207]:





-4.742376976370575e-21

In [208]:

    

2**0.5


    

    
Out[208]:





1.4142135623730951

In [ ]: