Sveučilište u Zagrebu
Fakultet elektrotehnike i računarstva
http://www.fer.unizg.hr/predmet/su
Ak. god. 2015./2016.
(c) 2015 Jan Šnajder
Verzija: 0.5 (2015-10-15)
NEPOTPUNO
Glavni paketi (core packages):
Dodatni paketi:
Ćelije se evaluiraju sa SHIFT+ENTER
Markdown tekst s posebnim formatiranjem i kodom u $\LaTeX$-u: $f(\mathbf{x}) = \sum_{i=1}^n \ln \frac{P(x)P(y)}{P(x, y)}$
10
10
_
10
55
10
?
%quickref
x = 5
x
5
print(x)
5
print x
5
type(x)
int
(x + 1) ** 2
36
x += 1; x
6
?x
del x
x
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-16-401b30e3b8b5> in <module>() ----> 1 x NameError: name 'x' is not defined
X=7; varijabla_s_vrlo_dugackim_imenom = 747
x=1; y=-2
x==y
(x==y)==False
x!=y
x==y or (x>0 and not y>0)
z = 42 if x==y else 66
z
moj_string = 'ringe ringe'
'hopa' + ' ' + "cupa"
moj_string += ' raja'; moj_string
len(moj_string)
print "X=%0.2f y=%d, s='%s'" % (x, y, moj_string)
1/2
1/2.0
1/float(2)
round(0.5)
import math
math.sqrt(68)
math.exp(1)
math.log(_)
math.log(100, 2)
xs = [5, 6, 2, 3] # Stvara listu
xs
xs[0] # Zero-based indeksiranje
xs[-1] # Negativni indeksi broje od kraja liste
xs[1] = 100 # Ažuriranje liste
xs
xs[1] = 'foo' # Liste mogu biti heterogene
xs
xs[3] = [1,2]
xs
xs.append(x) # Dodaje na kraj
xs
xs + [77, 88]
xs.extend([77, 88]); xs
xs.pop() # Skida zadnji element liste
xs
xs[0:2]
xs[1:]
xs[:3]
xs[:]
xs[:-2] # Sve osim zadnja dva
xs[0:2] = [1,2]
xs
range(10)
range(1, 10)
range(0, 51, 5)
for x in range(5):
print x
for x in xs: print x
for ix, x in enumerate(range(0, 51, 5)):
print ix, x
xs = []
for x in range(10):
xs.append(x ** 2)
xs
[x ** 2 for x in range(10)]
[x ** 2 for x in range(10) if x % 2 == 0]
[(x, x ** 2) for x in range(10)]
zip([1, 2, 3], [4, 5, 6])
zip(*[(1, 4), (2, 5), (3, 6)])
xs, ys = zip(*[(1, 4), (2, 5), (3, 6)])
xs
map(lambda x : x + 1, xs)
[ x + 1 for x in xs ]
ys = []
for x in xs :
ys.append(x + 1)
ys
sum(ys)
d = {'zagreb' : 790017, 'split' : 178102, 'rijeka' : 128624}
d['split']
178102
d['osijek']
--------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-19-b6288821d7a0> in <module>() ----> 1 d['osijek'] KeyError: 'osijek'
d.get('osijek', 0)
0
d['osijek'] = 108048; d
{'osijek': 108048, 'rijeka': 128624, 'split': 178102, 'zagreb': 790017}
'rijeka' in d
True
d['zagreb'] = 790200; d
{'osijek': 108048, 'rijeka': 128624, 'split': 178102, 'zagreb': 790200}
del d['rijeka']; d
{'osijek': 108048, 'split': 178102, 'zagreb': 790200}
Iteriranje po rječniku:
for grad in d:
print 'Grad %s ima %d stanovnika' % (grad, d[grad])
Grad osijek ima 108048 stanovnika Grad split ima 178102 stanovnika Grad zagreb ima 790200 stanovnika
Iteriranje po ključevima i po vrijednostima:
for grad, stanovnici in d.iteritems():
print 'Grad %s ima %d stanovnika' % (grad, stanovnici)
Grad osijek ima 108048 stanovnika Grad split ima 178102 stanovnika Grad zagreb ima 790200 stanovnika
Ugniježđeni rječnici:
d2 = {'zagreb' : {'trešnjevka' : 120240, 'centar' : 145302}}
d2 ['zagreb']['trešnjevka']
120240
def inc(x): return x + 1
def sign(x):
if x > 0:
return 'pozitivno'
elif x < 0:
return 'negativno'
else:
return 'nula'
for x in [-1, 0, 1]:
print sign(x)
negativno nula pozitivno
Podrazumijevani argumenti:
def broj_stanovnika(grad, godina=2015):
if grad in d:
return d[grad] + round((godina - 2015) * 10000 * (-1.2))
else:
raise ValueError('Nepoznat neki grad')
broj_stanovnika('zagreb')
790200.0
broj_stanovnika('zagreb', godina=2020)
730200.0
broj_stanovnika('zadar')
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-33-ed4c8aabd867> in <module>() ----> 1 broj_stanovnika('zadar') <ipython-input-30-4ea6caac6059> in broj_stanovnika(grad, godina) 3 return d[grad] + round((godina - 2015) * 10000 * (-1.2)) 4 else: ----> 5 raise ValueError('Nepoznat neki grad') ValueError: Nepoznat neki grad
class RegistarStanovnika:
# Konstruktor
def __init__(self, drzava, d):
self.drzava = drzava # Varijabla instance (drugačija za svaku instancu)
self.d = d
prirast = -1.2 # Varijabla klase (dijele ju sve instance)
# Metoda
def broj_stanovnika(self, grad, godina=2015):
if grad in self.d:
return self.d[grad] + round((godina - 2015) * 10000 * self.prirast)
else:
raise ValueError('Nepoznat neki grad')
def ukupno_stanovnika(self):
return sum(self.d.values())
reg = RegistarStanovnika('Hrvatska', {'zagreb' : 790017, 'split' : 178102, 'rijeka' : 128624})
reg.broj_stanovnika('split')
178102.0
reg.ukupno_stanovnika()
1096743
import numpy as np
?np
np.__version__
'1.10.0.post2'
Jednodimenzijsko polje (polje ranga 1):
a = np.array([1, 2, 3])
a
array([1, 2, 3])
print a
[1 2 3]
type(a)
numpy.ndarray
a = np.array([1, 2, 3], dtype=np.float64)
a
array([ 1., 2., 3.])
a[0]
1.0
a[0] = 100; a
array([ 100., 2., 3.])
a.shape
(3,)
len(a)
3
np.array([1,'a',2])
array(['1', 'a', '2'], dtype='|S21')
Matrica (dvodimenzijsko polje, polje ranga 2):
m = np.array([[1,2,3],[4,5,6]])
print m
[[1 2 3] [4 5 6]]
m[1]
array([4, 5, 6])
m[1,1]
5
m[1][1]
5
m.shape
(2, 3)
m2 = np.array([[1,2,3],[4,5]])
print m2
[[1, 2, 3] [4, 5]]
Izrezivanje (engl. slicing):
print m
[[1 2 3] [4 5 6]]
m[:,1]
array([2, 5])
m[0,1:3]
array([2, 3])
m[1,:2] = [77, 78]
m
array([[ 1, 2, 3], [77, 78, 6]])
Uočiti razliku:
m[:,0] # daje polje ranga 1
array([ 1, 77])
m[:,0:1] # daje polje ranga 2
array([[ 1], [77]])
Trodimenzijsko polje (tenzor ranga 3):
t = np.array([[[1,2],[3,4]],[[4,5],[6,7]]])
t.shape
(2, 2, 2)
t[0,1,1]
4
t[0]
array([[1, 2], [3, 4]])
t[0,:,1]
array([2, 4])
np.zeros((5,5))
array([[ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.]])
np.ones((3,1))
array([[ 1.], [ 1.], [ 1.]])
np.full((5,5), 55)
array([[ 55., 55., 55., 55., 55.], [ 55., 55., 55., 55., 55.], [ 55., 55., 55., 55., 55.], [ 55., 55., 55., 55., 55.], [ 55., 55., 55., 55., 55.]])
np.eye(6)
array([[ 1., 0., 0., 0., 0., 0.], [ 0., 1., 0., 0., 0., 0.], [ 0., 0., 1., 0., 0., 0.], [ 0., 0., 0., 1., 0., 0.], [ 0., 0., 0., 0., 1., 0.], [ 0., 0., 0., 0., 0., 1.]])
np.random.random((4,4))
array([[ 0.34294388, 0.2407478 , 0.54200906, 0.85047566], [ 0.84029626, 0.60056098, 0.84275663, 0.40206247], [ 0.59492988, 0.69943282, 0.67430892, 0.7806004 ], [ 0.07980246, 0.92217663, 0.35797981, 0.67351464]])
np.arange(1, 10)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
np.arange(1, 10, 2)
array([1, 3, 5, 7, 9])
np.linspace(1, 10, 5)
array([ 1. , 3.25, 5.5 , 7.75, 10. ])
np.linspace(1, 10)
array([ 1. , 1.18367347, 1.36734694, 1.55102041, 1.73469388, 1.91836735, 2.10204082, 2.28571429, 2.46938776, 2.65306122, 2.83673469, 3.02040816, 3.20408163, 3.3877551 , 3.57142857, 3.75510204, 3.93877551, 4.12244898, 4.30612245, 4.48979592, 4.67346939, 4.85714286, 5.04081633, 5.2244898 , 5.40816327, 5.59183673, 5.7755102 , 5.95918367, 6.14285714, 6.32653061, 6.51020408, 6.69387755, 6.87755102, 7.06122449, 7.24489796, 7.42857143, 7.6122449 , 7.79591837, 7.97959184, 8.16326531, 8.34693878, 8.53061224, 8.71428571, 8.89795918, 9.08163265, 9.26530612, 9.44897959, 9.63265306, 9.81632653, 10. ])
Indeksiranje poljem brojeva:
a = np.array([[1,2], [3, 4], [5, 6]]); a
array([[1, 2], [3, 4], [5, 6]])
a[0,1]
2
a[[0,2]] # Nije isto kao a[0,2] !
array([[1, 2], [5, 6]])
a[[0,1,2], [0,1,0]] # Isto kao: np.array([a[0,0], a[1,1], a[2,0]])
array([1, 4, 5])
Indeksiranje Booleovim poljem:
a
array([[1, 2], [3, 4], [5, 6]])
bool_ix = a > 2
bool_ix
array([[False, False], [ True, True], [ True, True]], dtype=bool)
a[bool_ix]
array([3, 4, 5, 6])
a[a > 2]
array([3, 4, 5, 6])
Širenje (eng. broadcasting):
x = np.array([[1, 2], [3, 4]])
v = np.array([1, 2])
print x
[[1 2] [3 4]]
x + v
array([[2, 4], [4, 6]])
np.ones((2,2,3)) * 5
array([[[ 5., 5., 5.], [ 5., 5., 5.]], [[ 5., 5., 5.], [ 5., 5., 5.]]])
Naslagivanje (engl. stacking):
v
array([1, 2])
np.vstack([v, v])
array([[1, 2], [1, 2]])
np.vstack([x, x])
array([[1, 2], [3, 4], [1, 2], [3, 4]])
np.vstack((v, x))
array([[1, 2], [1, 2], [3, 4]])
np.hstack((v, v))
array([1, 2, 1, 2])
np.hstack((x, x))
array([[1, 2, 1, 2], [3, 4, 3, 4]])
np.hstack((v, x))
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-45-6d17658301dc> in <module>() ----> 1 np.hstack((v, x)) /usr/local/lib/python2.7/dist-packages/numpy/core/shape_base.pyc in hstack(tup) 276 # As a special case, dimension 0 of 1-dimensional arrays is "horizontal" 277 if arrs[0].ndim == 1: --> 278 return _nx.concatenate(arrs, 0) 279 else: 280 return _nx.concatenate(arrs, 1) ValueError: all the input arrays must have same number of dimensions
np.column_stack((v, x))
array([[1, 1, 2], [2, 3, 4]])
x
array([[1, 2], [3, 4]])
np.dstack((x, x))
array([[[1, 1], [2, 2]], [[3, 3], [4, 4]]])
np.shape(_)
(2, 2, 2)
Preoblikovanje polja:
m = np.array([[ 1, 2, 3], [77, 78, 6]])
m.reshape(3, 2)
array([[ 1, 2], [ 3, 77], [78, 6]])
x = np.array([[1,2],[3,4]])
y = np.array([[5,6],[7,8]])
print x; print y
[[1 2] [3 4]] [[5 6] [7 8]]
Operacije "po elementima" (element-wise):
x + y
array([[ 6, 8], [10, 12]])
x - y
array([[-4, -4], [-4, -4]])
x / 2.0
array([[ 0.5, 1. ], [ 1.5, 2. ]])
x.dtype
dtype('int64')
(x/2.0).dtype
dtype('float64')
x * y
array([[ 5, 12], [21, 32]])
x.dtype='float64'
y.dtype='float64'
x / y
array([[ 0.2 , 0.33333333], [ 0.42857143, 0.5 ]])
np.sqrt(x)
array([[ 2.22275875e-162, 3.14345557e-162], [ 3.84993109e-162, 4.44551750e-162]])
Vektorske/matrične operacije:
x = np.array([[1,2],[3,4]])
y = np.array([[5,6],[7,8]])
v = np.array([1,2])
w = np.array([5,3])
Skalarni (unutarnji, dot) umnožak vektora: $ \begin{pmatrix} 1 & 2 \\ \end{pmatrix} \cdot \begin{pmatrix} 5\\ 3\\ \end{pmatrix} = 11 $
print v.dot(w)
print w.dot(v)
print np.dot(v, w)
11 11 11
Umnožak matrice i vektora: $ \begin{pmatrix} 1 & 2 \\ 3 & 4 \\ \end{pmatrix} \cdot \begin{pmatrix} 1\\ 2\\ \end{pmatrix} = \begin{pmatrix} 5\\ 11\\ \end{pmatrix} $
x.dot(v)
array([ 5, 11])
np.dot(x, v)
array([ 5, 11])
Umnožak vektora i matrice: $ \begin{pmatrix} 1 & 2\\ \end{pmatrix} \cdot \begin{pmatrix} 1 & 2 \\ 3 & 4 \\ \end{pmatrix} = \begin{pmatrix} 7 & 10\\ \end{pmatrix} $
v.dot(x)
array([ 7, 10])
np.dot(v,x)
array([ 7, 10])
Primijetite da nema razlike između vektor-stupca i vektor-retka.
Umnožak matrice i matrice: $ \begin{pmatrix} 1 & 2\\ 3 & 4\\ \end{pmatrix} \cdot \begin{pmatrix} 5 & 6 \\ 7 & 7 \\ \end{pmatrix} = \begin{pmatrix} 19 & 22\\ 43 & 50\\ \end{pmatrix} $
x.dot(y)
array([[19, 22], [43, 50]])
np.dot(x, y)
array([[19, 22], [43, 50]])
Vanjski umnožak vektora: $ \begin{pmatrix} 1\\ 2\\ \end{pmatrix} \times \begin{pmatrix} 5 \\ 3 \\ \end{pmatrix} = \begin{pmatrix} 1\\ 2\\ \end{pmatrix} \cdot \begin{pmatrix} 5 & 3\\ \end{pmatrix} = \begin{pmatrix} 5 & 3 \\ 10 & 6 \\ \end{pmatrix} $
np.outer(v, w)
array([[ 5, 3], [10, 6]])
Ostale operacije:
x = np.array([0, 2, 4, 1])
np.max(x)
4
np.argmax(x)
2
x = np.random.random(10); x
array([ 0.88042383, 0.22280293, 0.00769093, 0.9631947 , 0.82314693, 0.6021121 , 0.42227832, 0.54826309, 0.10995267, 0.27862066])
np.mean(x)
0.41554955347505657
np.median(x)
0.28811051704517238
np.var(x)
0.09738450671168114
np.std(x)
0.31206490785040403
x = np.array([1, 2, np.nan])
np.mean(x)
nan
np.nanmean(x)
1.5
np.ptp(x)
0.95550376524614955
X = np.array([[1,2],[3,4]])
print X
[[1 2] [3 4]]
np.mean(X)
2.5
np.mean(X, axis=0)
array([ 2., 3.])
np.cov(X)
array([[ 0.5, 0.5], [ 0.5, 0.5]])
x = np.random.random(10000); x
array([ 0.45896982, 0.98801242, 0.97315322, ..., 0.2251306 , 0.28813426, 0.77343545])
np.histogram(x)
(array([1028, 1024, 1029, 1022, 1014, 953, 1029, 960, 971, 970]), array([ 8.52564207e-05, 1.00051953e-01, 2.00018649e-01, 2.99985345e-01, 3.99952041e-01, 4.99918737e-01, 5.99885433e-01, 6.99852129e-01, 7.99818825e-01, 8.99785521e-01, 9.99752217e-01]))
x = np.array([[1,2],[3,4]]); x
array([[1, 2], [3, 4]])
np.sum(x)
10
np.sum(x, axis=0)
array([4, 6])
np.sum(x, axis=1)
array([3, 7])
x.T
array([[1, 3], [2, 4]])
v
array([1, 2])
v.T
array([1, 2])
x.diagonal()
array([1, 4])
x.trace() # == x.sum(x.diagonal())
5
Aplikacija funkcije na polje:
x
array([[1, 2], [3, 4]])
np.apply_along_axis(sum, 1, x)
array([3, 7])
np.apply_along_axis(len, 1, x)
array([2, 2])
Većina ugrađenih funkcija su vektorizirane, tj. moguće ih je primijeniti na cijelo polje tako da provode operaciju nad pojedinačnim elementima polja. Npr.:
np.sign(x)
array([[1, 1], [1, 1]])
np.log(x)
array([[ 0. , 0.69314718], [ 1.09861229, 1.38629436]])
Isto vrijedi i za korisnički definirane funkcije koje su definirane pomoći vektoriziranih ugrađenih funkcija:
def inc(x) : return x + 1
inc(x)
array([[2, 3], [4, 5]])
Složenije funkcije treba eksplicitno vektorizirati pomoću numpy.vectorize
(ili jednostavno aplicirati funkciju u for
petlji, što funkcija vectorize
zapravo i radi).
Permutacije:
x = np.arange(0,10); x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.random.permutation(x)
array([5, 3, 4, 0, 2, 7, 9, 8, 1, 6])
x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.random.shuffle(x); x
array([1, 2, 9, 4, 7, 8, 0, 6, 5, 3])
x
array([1, 2, 9, 4, 7, 8, 0, 6, 5, 3])
l = [1, 2, 3]
a = np.array(l); a
array([1, 2, 3])
list(a)
[1, 2, 3]
a.tolist()
[1, 2, 3]
l = [[1, 2, 3], [4,5,6]]
a = np.array(l); a
array([[1, 2, 3], [4, 5, 6]])
list(a)
[array([1, 2, 3]), array([4, 5, 6])]
a.tolist()
[[1, 2, 3], [4, 5, 6]]
import scipy as sp
sp.__version__
'0.16.0'
SciPy importa NumPy. Npr.:
x = sp.array([1,2,3])
Iz biblioteke SciPy interesantni su nam moduli scipy.linalg
i scipy.stats
.
from scipy import linalg
Inverz matrice:
y
array([[5, 6], [7, 8]])
y_inv = linalg.inv(y); y_inv
array([[-4. , 3. ], [ 3.5, -2.5]])
sp.dot(y, y_inv)
array([[ 1.00000000e+00, 3.55271368e-15], [ 0.00000000e+00, 1.00000000e+00]])
Determinanta:
linalg.det(y)
-2.0000000000000036
Euklidska norma ($l_2$-norma) vektora: $\|\mathbf{x}\|_2 = \sqrt{\sum_i x_i^2}$
w
array([5, 3])
linalg.norm(w)
5.8309518948453007
Općenita $p$-norma: $\|\mathbf{x}\|_p = \big(\sum_i |x_i|^p\big)^{1/p}$
linalg.norm(w, ord=1)
8
linalg.norm(w, ord=sp.inf)
5
from scipy import stats
stats.norm
<scipy.stats._continuous_distns.norm_gen at 0x7f970ba55e10>
stats.norm.pdf(0)
0.3989422804014327
xs = sp.linspace(-2, 2, 10);
stats.norm.pdf(xs)
array([ 0.05399097, 0.11897819, 0.21519246, 0.31944801, 0.38921247, 0.38921247, 0.31944801, 0.21519246, 0.11897819, 0.05399097])
stats.norm.pdf(xs, loc=1, scale=2)
array([ 0.0647588 , 0.08817395, 0.11427077, 0.14095594, 0.16549503, 0.18494385, 0.19671986, 0.19916355, 0.19192205, 0.17603266])
Uzorkovanje iz normalne distribucije:
stats.norm.rvs(loc=1, scale=2, size=10)
array([-0.58147381, 3.71386122, 1.24616214, 1.79738483, 2.69992991, -0.01069313, 3.30819964, 1.69645732, 1.09588046, -1.44891004])
"Zamrzavanje" distribucije:
normal = stats.norm(1, 2)
normal.pdf(xs)
array([ 0.0647588 , 0.08817395, 0.11427077, 0.14095594, 0.16549503, 0.18494385, 0.19671986, 0.19916355, 0.19192205, 0.17603266])
normal.rvs(size=5)
array([-2.20691566, 0.9434288 , -3.30867649, -1.24524492, -0.95381916])
Multivarijatna Gaussova distribucija:
?stats.multivariate_normal
mean = sp.array([1.0, 3.0])
cov = sp.array([[2.0, 0.3], [0.5, 0.7]])
mnormal = stats.multivariate_normal(mean, cov)
mnormal.pdf([1, 0])
5.9244062489471738e-05
np.random.seed(42) # Radi reproducibilnosti rezultata
mnormal.rvs(size=5)
array([[ 0.32295504, 2.7257843 ], [-0.19250187, 3.91415511], [ 1.37357915, 2.90579424], [-1.37198427, 3.02935659], [ 1.56503442, 3.5666907 ]])
Koeficijent korelacije:
x, y = np.random.random((2, 10))
y
array([ 0.45606998, 0.78517596, 0.19967378, 0.51423444, 0.59241457, 0.04645041, 0.60754485, 0.17052412, 0.06505159, 0.94888554])
stats.pearsonr(x, y)
(0.30346130585985159, 0.39400530307438952)
matplotlib
sadrži više modula: pyplot
, image
, matplot3d
, ...
import matplotlib.pyplot as plt
import matplotlib
matplotlib.__version__
'1.4.3'
%pylab inline
Populating the interactive namespace from numpy and matplotlib
WARNING: pylab import has clobbered these variables: ['linalg', 'cov', 'normal', 'mean'] `%matplotlib` prevents importing * from pylab and numpy
pylab
kombinira pyplot
i numpy
. Gornja naredba (ipython magic) osigurava da pplotovi budu renderirani direktno u bilježnicu, umjesto da otvoaraju zaseban prozor.
plot
¶plt.plot([1,2,3,4,5], [4,5,5,7,3])
plt.show()
plt.plot([4,5,5,7,3]);
plt.plot([4,5,5,7,3], 'ro');
def f(x) : return x**2
xs = linspace(0,100); xs
array([ 0. , 2.04081633, 4.08163265, 6.12244898, 8.16326531, 10.20408163, 12.24489796, 14.28571429, 16.32653061, 18.36734694, 20.40816327, 22.44897959, 24.48979592, 26.53061224, 28.57142857, 30.6122449 , 32.65306122, 34.69387755, 36.73469388, 38.7755102 , 40.81632653, 42.85714286, 44.89795918, 46.93877551, 48.97959184, 51.02040816, 53.06122449, 55.10204082, 57.14285714, 59.18367347, 61.2244898 , 63.26530612, 65.30612245, 67.34693878, 69.3877551 , 71.42857143, 73.46938776, 75.51020408, 77.55102041, 79.59183673, 81.63265306, 83.67346939, 85.71428571, 87.75510204, 89.79591837, 91.83673469, 93.87755102, 95.91836735, 97.95918367, 100. ])
f(xs)
array([ 0.00000000e+00, 4.16493128e+00, 1.66597251e+01, 3.74843815e+01, 6.66389005e+01, 1.04123282e+02, 1.49937526e+02, 2.04081633e+02, 2.66555602e+02, 3.37359434e+02, 4.16493128e+02, 5.03956685e+02, 5.99750104e+02, 7.03873386e+02, 8.16326531e+02, 9.37109538e+02, 1.06622241e+03, 1.20366514e+03, 1.34943773e+03, 1.50354019e+03, 1.66597251e+03, 1.83673469e+03, 2.01582674e+03, 2.20324865e+03, 2.39900042e+03, 2.60308205e+03, 2.81549354e+03, 3.03623490e+03, 3.26530612e+03, 3.50270721e+03, 3.74843815e+03, 4.00249896e+03, 4.26488963e+03, 4.53561016e+03, 4.81466056e+03, 5.10204082e+03, 5.39775094e+03, 5.70179092e+03, 6.01416077e+03, 6.33486047e+03, 6.66389005e+03, 7.00124948e+03, 7.34693878e+03, 7.70095793e+03, 8.06330696e+03, 8.43398584e+03, 8.81299459e+03, 9.20033319e+03, 9.59600167e+03, 1.00000000e+04])
plt.plot(xs, f(xs));
plt.plot(xs, f(xs), 'bo');
plt.plot(xs, f(xs), 'r+');
plt.plot(xs, 1 - f(xs), 'b', xs, f(xs)/2 - 1000, 'r--');
plt.plot(xs, f(xs), label='f(x)')
plt.plot(xs, 1 - f(xs), label='1-f(x)')
plt.legend()
plt.show()
xs = linspace(-5,5)
plt.plot(xs, stats.norm.pdf(xs), 'g--');
plt.plot(xs, stats.norm.pdf(xs, loc=1, scale=2), 'r', linewidth=3);
scatter
¶plt.scatter([0, 1, 2, 0], [4, 5, 2, 1])
plt.show()
plt.scatter([0,1,2,0], [4, 5, 2, 1], s=200, marker='s');
np.random.random(10)
array([ 0.96563203, 0.80839735, 0.30461377, 0.09767211, 0.68423303, 0.44015249, 0.12203823, 0.49517691, 0.03438852, 0.9093204 ])
for c in 'rgb':
plt.scatter(sp.random.random(100), sp.random.random(100), s=200, alpha=0.5, marker='o', c=c)
x = np.linspace(1,5,5); x
array([ 1., 2., 3., 4., 5.])
X, Y = np.meshgrid(x, x)
X
array([[ 1., 2., 3., 4., 5.], [ 1., 2., 3., 4., 5.], [ 1., 2., 3., 4., 5.], [ 1., 2., 3., 4., 5.], [ 1., 2., 3., 4., 5.]])
Y
array([[ 1., 1., 1., 1., 1.], [ 2., 2., 2., 2., 2.], [ 3., 3., 3., 3., 3.], [ 4., 4., 4., 4., 4.], [ 5., 5., 5., 5., 5.]])
Z = 10 * X + Y
Z
array([[ 11., 21., 31., 41., 51.], [ 12., 22., 32., 42., 52.], [ 13., 23., 33., 43., 53.], [ 14., 24., 34., 44., 54.], [ 15., 25., 35., 45., 55.]])
plt.pcolormesh(X, Y, Z, cmap='gray')
plt.show()
mnormal = stats.multivariate_normal([0, 1], [[1, 1], [0.2, 3]])
mnormal.pdf([1,1])
0.055730458106194758
x = np.linspace(-1, 1)
y = np.linspace(-2, 2)
X, Y = np.meshgrid(x, y)
shape(X)
(50, 50)
shape(XY)
(50, 50, 2)
mnormal.pdf(XY)
array([[ 0.01492383, 0.01541297, 0.01589129, ..., 0.01095132, 0.01044738, 0.00994981], [ 0.01610377, 0.01663533, 0.01715544, ..., 0.01194288, 0.01139588, 0.01085559], [ 0.01733793, 0.01791426, 0.01847852, ..., 0.01299494, 0.01240254, 0.01181718], ..., [ 0.04679266, 0.04884039, 0.05089173, ..., 0.05646055, 0.0544354 , 0.05239434], [ 0.04542256, 0.04742101, 0.04942386, ..., 0.05539039, 0.05341564, 0.0514244 ], [ 0.04399343, 0.04593934, 0.04789039, ..., 0.0542183 , 0.05229712, 0.05035891]])
plt.pcolormesh(X, Y, mnormal.pdf(XY))
plt.show()
plt.contourf(X, Y, mnormal.pdf(XY));
plt.contourf(X, Y, mnormal.pdf(XY), levels=[0,0.06, 0.07]);
plt.contour(X, Y, mnormal.pdf(XY));
x = linspace(-10,10)
X, Y = np.meshgrid(x, x)
Z = X*3 + Y
plt.contour(X, Y, Z);
plt.contour(X, Y, Z, levels=[0]);
Kombinacija više grafikona:
plt.contour(X, Y, Z, levels=[0])
plt.scatter([-5,-3,2,5], [4, 5, 2, 1])
plt.show()
np.random.seed(42)
x = stats.norm.rvs(size=1000)
plt.hist(x);
Više-manje istovjetno s:
hist, bins = np.histogram(x)
centers = (bins[:-1] + bins[1:]) / 2
plt.bar(centers, hist);
TODO
import pandas as pd
pd.__version__
u'0.17.0'
TODO
import sklearn
sklearn.__version__
'0.15.2'
TODO