Python Primer
March 1, 2016
1 Python
1.1 Lists and Tuples
1.1.1 Indexing into list
In [1]: l = [1, 2, 3] # make a list
l[1] # index into it
Out[1]: 2
1.1.2 Appending to a list
In [2]: l.append(4) # add to it
l
Out[2]: [1, 2, 3, 4]
1.1.3 Deleting an element
In [3]: del l[1]
l
Out[3]: [1, 3, 4]
1.1.4 Inserting an element
In [4]: l.insert(1, 3) # insert into it
l
Out[4]: [1, 3, 3, 4]
1.1.5 Tuples
In [5]: t = (1, 3, 3, 4) # make a tuple
l == t
Out[5]: False
1.1.6 List to Tuple
In [6]: t2 = tuple(l)
t2 == t
Out[6]: True
1
1.2 Dictionaries
In [7]: Dict = {}
Dict[1] = 2
Dict[one] = two
Dict[1] = 2
Dict
Out[7]: {1: 2, 1: 2, one: two}
1.2.1 Keys in Dictionary
In [8]: print "Dictionary keys"
print Dict.keys()
print "\nValue at 1 :"
print Dict[1]
print "\nValue at one"
print Dict[one]
one = 1
print "\nValue at 1"
print Dict[one]
print "\nIterate over keys"
for key in Dict.keys():
print key
print "\nDelete key : 1"
del Dict[1]
print Dict
Dictionary keys
[1, 1, one]
Value at 1 :
2
Value at one
two
Value at 1
2
Iterate over keys
1
1
one
Delete key : 1
{1: 2, one: two}
2
2 Classes and Function
2.1 Functions
In [9]: def printer(x):
print x
def adder(x,y):
return x+y
def square(x):
return x**2
a = 2
b = 3
print "Lets print a:"
printer(a)
print "\nLets print a + b"
printer(adder(a,b))
print "\n So you can pass the return of a function to another function just like everywhere. \n
printer(square(adder(a,b)))
Lets print a:
2
Lets print a + b
5
So you can pass the return of a function to another function just like everywhere.
Lets take it another step further
25
2.2 Classes
In [10]: class student(object):
def __init__(self,name = None ,age = None):
if name == None:
self.name = "Amartya"
else:
self.name = name
if age == None:
self.age = 20
else:
self.age = age
def update_name(self,name):
self.name = name
def update_age(self,age):
self.age = age
def inc_age(self):
self.age = self.age + 1
3
def return_info(self):
temp = [self.name, self.age]
return temp
In [11]: Amartya = student()
print"Amartya:"
print vars(Amartya)
Bhuvesh = student("Bhuvesh", 21)
print "\nBhuvesh:"
print vars(Bhuvesh)
print "\nIncrementing Bhuveshs age"
Bhuvesh.inc_age()
print vars(Bhuvesh)
print "\nMake Amartya a baby"
Amartya.update_age(1)
print vars(Amartya)
print "\nA list of attributes of Amartya(Just to show what lists are)"
print Amartya.return_info()
Amartya:
{age: 20, name: Amartya}
Bhuvesh:
{age: 21, name: Bhuvesh}
Incrementing Bhuveshs age
{age: 22, name: Bhuvesh}
Make Amartya a baby
{age: 1, name: Amartya}
A list of attributes of Amartya(Just to show what lists are)
[Amartya, 1]
3 Exceptions
In [12]: print "Adding 2 and 3"
printer(adder(2,3))
print "\nAdding Amartya and Bhuvesh"
printer(adder("amartya","bhuvesh"))
print "\nBut say we want to practical and only add numbers , not people."
def adder(x,y):
try:
if type(x) != int or type(x) != float or type(y) != int or type(y) != float:
raise ValueError()
4
else:
return x+y
except ValueError:
print "Error!! Error!! You cant add people\n"
print "\nAdding Amartya and Bhuvesh"
printer(adder("amartya","bhuvesh"))
Adding 2 and 3
5
Adding Amartya and Bhuvesh
amartyabhuvesh
But say we want to practical and only add numbers , not people.
Adding Amartya and Bhuvesh
Error!! Error!! You cant add people
None
4 Starting Numpy
In [13]: import numpy as np #Please dont forget this
4.1 Basic types of arrays and matrices
4.1.1 Zero Array and Zero Matrix
In [14]: zeroArray = np.zeros(5)
print "Zero Array"
print zeroArray
print "\nZero Matrix:"
zeroArray = np.zeros([5,10])
print zeroArray
Zero Array
[ 0. 0. 0. 0. 0.]
Zero Matrix:
[[ 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. 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.]]
4.1.2 Ones array and Ones Matrix
In [15]: oneArray = np.ones(5)
print "Ones Array"
print oneArray
print "\nOnes Matrix:"
oneArray = np.ones([5,10])
print oneArray
5
Ones Array
[ 1. 1. 1. 1. 1.]
Ones Matrix:
[[ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
[ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
[ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
[ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
[ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]
4.1.3 Identity Matrix
In [16]: I = np.identity(5)
print "Identity Matrix"
print I
Identity Matrix
[[ 1. 0. 0. 0. 0.]
[ 0. 1. 0. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 1.]]
4.1.4 Basic vector stuff
In [17]: A = [1, 2, 3]
B = np.asarray(A)
C = [4,5,6]
D = np.asarray(C)
In [18]: print "Elementwise Multiplication"
print B*D
print "\nElementwise Addition"
print B+D
print "\n Dot Product"
print np.dot(B,D)
Elementwise Multiplication
[ 4 10 18]
Elementwise Addition
[5 7 9]
Dot Product
32
In [19]: print "Lets square each element in the array"
print [x**2 for x in C]
print "\n Lets do some more complicated function"
def updateX(x):
x = x + 2
x = np.log(x)
x = np.power(x,2)
return x
print [updateX(x) for x in C]
6
Lets square each element in the array
[16, 25, 36]
Lets do some more complicated function
[3.2104019955684011, 3.7865663081964716, 4.3240771252638117]
4.1.5 Useful stuffs that make your life easy when coding stuffs.
In [20]: print "Createing an array of numbers from 1 to 9"
A = np.arange(1,10)
print A
print "\n Reshape an array to matrix"
B = np.reshape(A,[3,3])
print B
print "\n Transpose the matrix"
C = np.transpose(B)
print C
print "\n Make elements less than 5 0"
C[C<5] = 0
print C
Createing an array of numbers from 1 to 9
[1 2 3 4 5 6 7 8 9]
Reshape an array to matrix
[[1 2 3]
[4 5 6]
[7 8 9]]
Transpose the matrix
[[1 4 7]
[2 5 8]
[3 6 9]]
Make elements less than 5 0
[[0 0 7]
[0 5 8]
[0 6 9]]
In [21]: print "Summing up elements"
print "\n Each column"
print np.sum(C,axis=0)
print "\n Each row"
print np.sum(C,axis=1)
Summing up elements
Each column
[ 0 11 24]
Each row
[ 7 13 15]
7
In [22]: print "Mean of elements"
print "\n Each column"
print np.mean(C,axis=0)
print "\n Each row"
print np.mean(C,axis=1)
Mean of elements
Each column
[ 0. 3.66666667 8. ]
Each row
[ 2.33333333 4.33333333 5. ]
In [23]: print "Product of elements"
print "\n Each column"
print np.prod(C,axis=0)
print "\n Each row"
print np.prod(C,axis=1)
Product of elements
Each column
[ 0 0 504]
Each row
[0 0 0]
5 Finally Theano!
In [24]: import theano
import theano.tensor as T
In [25]: # Create the scalars
x = T.scalar()
y = T.scalar()
In [26]: print "Add two numbers"
temp1 = x + y
# So this is how you add two "Symbolic variables"
addTh = theano.function([x,y],temp1)
theano.pp(addTh.maker.fgraph.outputs[0])
Add two numbers
Out[26]: (<TensorType(float64, scalar)> + <TensorType(float64, scalar)>)
In [27]: print addTh(1,2)
3.0
In [28]: print "Comparing two numbers"
temp1 = T.le(x, y)
compTh = theano.function([x,y],temp1)
8
theano.pp(compTh.maker.fgraph.outputs[0])
print compTh(4,3)
Comparing two numbers
0
In [29]: print "If else operator in Theano"
xgy = T.ge(x,y)
res = 2*x*xgy + (1 - xgy)*3*x
ifelse = theano.function([x,y],res)
print ""
print theano.pp(compTh.maker.fgraph.outputs[0])
print ""
print ifelse(5,4)
If else operator in Theano
le(<TensorType(float64, scalar)>, <TensorType(float64, scalar)>)
10.0
In [30]: #Create the symbolic graph
z = x + y
w = z * x
a = T.sqrt(w)
b = T.exp(a)
c = a ** b
d = T.log(c)
uselessFunc = theano.function([x,y],d)
theano.pp(uselessFunc.maker.fgraph.outputs[0])
Out[30]: Elemwise{Composite{log((Composite{sqrt(((i0 + i1) * i0))}(i0, i1) ** exp(Composite{sqrt(((i0 +
In [31]: print uselessFunc(1,4)
7.52932798092
5.1 Wheres the vector stuff
In [32]: x = T.vector(x)
y = T.vector(y)
A = np.asarray([1,2,3])
B = np.asarray([4,5,6])
In [33]: xdoty = T.dot(x,y)
xaddy = T.sum(x+y)
dotfn = theano.function([x,y], xdoty)
print "Lets do dot product in theano"
print A,B,dotfn(A,B)
print "\nFunctions with more than one outputs"
9
dotaddfn = theano.function([x,y], [xdoty,xaddy])
print dotaddfn(A,B)
print "\n All element wise operations are similar to numpy"
Lets do dot product in theano
[1 2 3] [4 5 6] 32.0
Functions with more than one outputs
[array(32.0), array(21.0)]
All element wise operations are similar to numpy
5.1.1 The famous logistic function
In [34]: x = T.matrix(x)
s = 1 / (1 + T.exp(-x))
logistic = theano.function([x], s)
print theano.pp(logistic.maker.fgraph.outputs[0])
logistic([[0, 1], [-1, -2]])
sigmoid(x)
Out[34]: array([[ 0.5 , 0.73105858],
[ 0.26894142, 0.11920292]])
5.2 The update comes in
In [35]: state = theano.shared(0)
inc = T.iscalar(inc)
#Update the state by incrementing it with inc
accumulator = theano.function([inc], state, updates=[(state, state+inc)])
In [36]: for i in range(0,10):
accumulator(i)
# In order to get the value of the accumulated
print state.get_value()
# We can also set the value of a shared variable
state.set_value(0)
0
1
3
6
10
15
21
28
36
45
10
5.3 As you might have guessed ML is a lot about updating parameters to
achieve lowest cost
5.4 But then we need to choose what to update it with
5.5 Gear up for some magic
5.6 Gradient Magic
In [37]: a = T.scalar(a)
b = T.sqr(a)
c = T.grad(b,a)
gradfn = theano.function([a],c)
print theano.pp(gradfn.maker.fgraph.outputs[0])
print gradfn(4)
(TensorConstant{2.0} * a)
8.0
In [38]: B = theano.shared(np.asarray([1.,2.]))
R = T.sqr(B).sum()
A = T.grad(R, B)
Z = theano.function([], R, updates={B: B - .1*A})
for i in range(10):
print(cost function = {}.format(Z()))
print(parameters = {}.format(B.get_value()))
# Try to change range to 100 to see what happens
cost function = 5.0
parameters = [ 0.8 1.6]
cost function = 3.2
parameters = [ 0.64 1.28]
cost function = 2.048
parameters = [ 0.512 1.024]
cost function = 1.31072
parameters = [ 0.4096 0.8192]
cost function = 0.8388608
parameters = [ 0.32768 0.65536]
cost function = 0.536870912
parameters = [ 0.262144 0.524288]
cost function = 0.34359738368
parameters = [ 0.2097152 0.4194304]
cost function = 0.219902325555
parameters = [ 0.16777216 0.33554432]
cost function = 0.140737488355
parameters = [ 0.13421773 0.26843546]
cost function = 0.0900719925474
parameters = [ 0.10737418 0.21474836]
In [ ]:
In [ ]:
In [ ]:
11
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
12
