Программирование на Python

Дзен Python



In [159]:

    
%pylab inline









    



Populating the interactive namespace from numpy and matplotlib






    



C:\ProgramData\Anaconda3\lib\site-packages\IPython\core\magics\pylab.py:160: UserWarning: pylab import has clobbered these variables: ['f']
`%matplotlib` prevents importing * from pylab and numpy
  "\n`%matplotlib` prevents importing * from pylab and numpy"



In [1]:

    
import this









    



The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Красивое лучше, чем уродливое.
Явное лучше, чем неявное.
Простое лучше, чем сложное.
Сложное лучше, чем запутанное.
Плоское лучше, чем вложенное.
Разреженное лучше, чем плотное.
Читаемость имеет значение.
Особые случаи не настолько особые, чтобы нарушать правила.
При этом практичность важнее безупречности.
Ошибки никогда не должны замалчиваться.
Если не замалчиваются явно.
Встретив двусмысленность, отбрось искушение угадать.
Должен существовать один — и, желательно, только один — очевидный способ сделать это.
Хотя он поначалу может быть и не очевиден, если вы не голландец.
Сейчас лучше, чем никогда.
Хотя никогда зачастую лучше, чем прямо сейчас.
Если реализацию сложно объяснить — идея плоха.
Если реализацию легко объяснить — идея, возможно, хороша.
Пространства имён — отличная штука! Будем делать их побольше!



In [1]:

    
import numpy as np



In [2]:

    
np.array([1,2,3])









    Out[2]:





array([1, 2, 3])



In [114]:

    
a = np.array([[1,2,3], [4,5,6]])



In [8]:

    
a = np.array([1,2,3])
b = np.array([4,5,6])



In [9]:

    
a+b









    Out[9]:





array([5, 7, 9])



In [10]:

    
a*b









    Out[10]:





array([ 4, 10, 18])



In [11]:

    
a/b









    Out[11]:





array([ 0.25,  0.4 ,  0.5 ])



In [12]:

    
a**b









    Out[12]:





array([  1,  32, 729], dtype=int32)

Типы данных в np.array

Целые знаковые

np.int8
np.int16
np.int32
np.int64

Целые беззнаковые

np.uint8
np.uint16
np.uint32
np.uint64

С плавающей точкой

np.float16
np.float32
np.float64



In [4]:

    
np.array([1, 2, 4], dtype=np.float32)









    Out[4]:





array([ 1.,  2.,  4.], dtype=float32)



In [7]:

    
a = np.array([1,2,3])
print(a.dtype)
print(a.astype(np.float64).dtype)









    



int32
float64

Создание массивов в numpy

Диапозон значений



In [16]:

    
np.arange(2, 10, 3, dtype=np.float32)









    Out[16]:





array([ 2.,  5.,  8.], dtype=float32)



In [22]:

    
np.linspace(1,10,10000)









    Out[22]:





array([  1.        ,   1.00090009,   1.00180018, ...,   9.99819982,
         9.99909991,  10.        ])

Заполнение массива



In [32]:

    
np.zeros((3,1),dtype=np.float16)









    Out[32]:





array([[ 0.],
       [ 0.],
       [ 0.]], dtype=float16)



In [26]:

    
np.ones((5,3),dtype=np.float16)









    Out[26]:





array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float16)

Случайные значения



In [45]:

    
np.random.random((4,2,3))









    Out[45]:





array([[[ 0.05959252,  0.13711514,  0.68488591],
        [ 0.10374813,  0.82594138,  0.98925713]],

       [[ 0.46099318,  0.94240566,  0.91102718],
        [ 0.76982087,  0.0418647 ,  0.85020438]],

       [[ 0.18375257,  0.48684789,  0.90501116],
        [ 0.87641679,  0.91814405,  0.89764521]],

       [[ 0.90064442,  0.78076648,  0.63909825],
        [ 0.07064647,  0.90386935,  0.24579875]]])



In [49]:

    
np.random.randint(1,10,(5,3))









    Out[49]:





array([[5, 9, 5],
       [2, 1, 9],
       [2, 4, 2],
       [4, 9, 9],
       [8, 5, 3]])



In [101]:

    
np.random.normal(5, 6, (4,2))









    Out[101]:





array([[ 2.18315368,  8.25536026],
       [ 2.21949384,  2.20562148],
       [ 6.45177363, -6.47968147],
       [-5.349507  ,  1.62627482]])



In [99]:

    
np.random.seed(42)



In [ ]:



In [102]:

    
a = np.zeros((3,2))
b = np.ones((3,2))



In [108]:

    
np.hstack([a,b])









    Out[108]:





array([[ 0.,  0.,  1.,  1.],
       [ 0.,  0.,  1.,  1.],
       [ 0.,  0.,  1.,  1.]])



In [109]:

    
np.vstack([a, b])









    Out[109]:





array([[ 0.,  0.],
       [ 0.,  0.],
       [ 0.,  0.],
       [ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.]])



In [119]:

    
a









    Out[119]:





array([[1, 2, 3],
       [4, 5, 6]])



In [142]:

    
a.shape









    Out[142]:





(2, 3)



In [120]:

    
b = np.array([[1,2],[3,4],[5,6]])



In [124]:

    
b.T









    Out[124]:





array([[1, 3, 5],
       [2, 4, 6]])



In [121]:

    
a.dot(b)









    Out[121]:





array([[22, 28],
       [49, 64]])



In [ ]:



In [140]:

    
X = np.arange(1,11).reshape((-1,1))
y = np.arange(2,12)+np.random.normal(size=(10))
y = y.reshape((-1,1))



In [168]:

    
W = np.random.random((2,1))

$$f(x) = kx+b$$$$f(x) = X*W$$



In [146]:

    
X = np.hstack([X, np.ones((10,1))])



In [150]:

    
f(X)









    Out[150]:





array([[ 0.39445638],
       [ 0.7253544 ],
       [ 1.05625242],
       [ 1.38715045],
       [ 1.71804847],
       [ 2.0489465 ],
       [ 2.37984452],
       [ 2.71074255],
       [ 3.04164057],
       [ 3.3725386 ]])

$$MSE(X,\omega, y) = \frac{1}{N} \sum_i (f(x_i, \omega) - y_i)^2$$$$\frac{dMSE}{dk} = \frac{2}{N} \sum_i (f(x_i, \omega) - y_i)*x_i$$$$\frac{dMSE}{db} = \frac{2}{N} \sum_i (f(x_i, \omega) - y_i)$$

$$MSE(X,\omega, y) = \frac{1}{N}*(X*W - y)*(X*W - y)$$$$\frac{dMSE}{dk} = \frac{2}{N}*(X*W - y)*x$$$$\frac{dMSE}{db} = \frac{2}{N} \sum (X*W - y)$$

$$dMSE = \frac{2}{N} * (X * W-y)*X$$

$$W_{i+1} = W_{i}-\alpha*dMSE(X, W_i, y)$$



In [314]:

    
def f(X, W):
    return X.dot(W)



In [154]:

    
def MSE(X, W, y):
    return (X.dot(W)-y).T.dot(X.dot(W)-y)/X.shape[0]



In [156]:

    
def dMSE(X, W, y):
    return 2/X.shape[0]*X.T.dot((X.dot(W)-y))



In [183]:

    
def optimize(W,X,y,a):
    for i in range(1000):
        W = W - a*dMSE(X,W,y)



In [155]:

    
MSE(X, W, y)









    Out[155]:





array([[ 27.88769561]])



In [157]:

    
dMSE(X,W,y)









    Out[157]:





array([[-64.84193771],
       [ -9.63188788]])



In [289]:

    
def optimize(W,X,y,a):
    global coef, mses
    coef = []
    mses = []
    for i in range(1000):
        coef.append(W)
        mses.append(MSE(X,W,y)[0,0])
        W = W - a*dMSE(X,W,y)
#         print(MSE(X,W,y))
    return W



In [309]:

    
W = np.random.random((2,1))
P = optimize(W, X, y, 0.02)



In [310]:

    
coef = np.array(coef)



In [311]:

    
ylabel("k")
xlabel("b")
plot(coef[:,0,0], coef[:,1,0]);



In [312]:

    
ylabel("MSE")
xlabel("iteration")
plot(mses);



In [315]:

    
scatter(X[:,0],y.reshape(-1))
plot(X[:,0], f(X, W))
plot(X[:,0], f(X, P))









    Out[315]:





[<matplotlib.lines.Line2D at 0xa81cfd0>]



In [ ]: