import torch
import matplotlib.pyplot as plt
import random
import ipywidgets as widgets
From the ipywidget docs:
w = widgets.Button(description='Click me')
w
Button(description='Click me', style=ButtonStyle())
def f(o): print('hi')
w.on_click(f)
NB: When callbacks are used in this way they are often called "events".
from time import sleep
def slow_calculation():
res = 0
for i in range(5):
res += i*i
sleep(1)
return res
slow_calculation()
30
def slow_calculation(cb=None):
res = 0
for i in range(5):
res += i*i
sleep(1)
if cb: cb(i)
return res
def show_progress(epoch): print(f"Awesome! We've finished epoch {epoch}!")
slow_calculation(show_progress)
Awesome! We've finished epoch 0! Awesome! We've finished epoch 1! Awesome! We've finished epoch 2! Awesome! We've finished epoch 3! Awesome! We've finished epoch 4!
30
slow_calculation(lambda o: print(f"Awesome! We've finished epoch {o}!"))
Awesome! We've finished epoch 0! Awesome! We've finished epoch 1! Awesome! We've finished epoch 2! Awesome! We've finished epoch 3! Awesome! We've finished epoch 4!
30
def show_progress(exclamation, epoch): print(f"{exclamation}! We've finished epoch {epoch}!")
slow_calculation(lambda o: show_progress("OK I guess", o))
OK I guess! We've finished epoch 0! OK I guess! We've finished epoch 1! OK I guess! We've finished epoch 2! OK I guess! We've finished epoch 3! OK I guess! We've finished epoch 4!
30
def make_show_progress(exclamation):
def _inner(epoch): print(f"{exclamation}! We've finished epoch {epoch}!")
return _inner
slow_calculation(make_show_progress("Nice!"))
Nice!! We've finished epoch 0! Nice!! We've finished epoch 1! Nice!! We've finished epoch 2! Nice!! We've finished epoch 3! Nice!! We've finished epoch 4!
30
from functools import partial
slow_calculation(partial(show_progress, "OK I guess"))
OK I guess! We've finished epoch 0! OK I guess! We've finished epoch 1! OK I guess! We've finished epoch 2! OK I guess! We've finished epoch 3! OK I guess! We've finished epoch 4!
30
f2 = partial(show_progress, "OK I guess")
class ProgressShowingCallback():
def __init__(self, exclamation="Awesome"): self.exclamation = exclamation
def __call__(self, epoch): print(f"{self.exclamation}! We've finished epoch {epoch}!")
cb = ProgressShowingCallback("Just super")
slow_calculation(cb)
Just super! We've finished epoch 0! Just super! We've finished epoch 1! Just super! We've finished epoch 2! Just super! We've finished epoch 3! Just super! We've finished epoch 4!
30
*args and **kwargs¶def f(*a, **b): print(f"args: {a}; kwargs: {b}")
f(3, 'a', thing1="hello")
args: (3, 'a'); kwargs: {'thing1': 'hello'}
def g(a,b,c=0): print(a,b,c)
args = [1,2]
kwargs = {'c':3}
g(*args, **kwargs)
1 2 3
def slow_calculation(cb=None):
res = 0
for i in range(5):
if cb: cb.before_calc(i)
res += i*i
sleep(1)
if cb: cb.after_calc(i, val=res)
return res
class PrintStepCallback():
def before_calc(self, *args, **kwargs): print(f"About to start")
def after_calc (self, *args, **kwargs): print(f"Done step")
slow_calculation(PrintStepCallback())
About to start Done step About to start Done step About to start Done step About to start Done step About to start Done step
30
class PrintStatusCallback():
def __init__(self): pass
def before_calc(self, epoch, **kwargs): print(f"About to start: {epoch}")
def after_calc (self, epoch, val, **kwargs): print(f"After {epoch}: {val}")
slow_calculation(PrintStatusCallback())
About to start: 0 After 0: 0 About to start: 1 After 1: 1 About to start: 2 After 2: 5 About to start: 3 After 3: 14 About to start: 4 After 4: 30
30
def slow_calculation(cb=None):
res = 0
for i in range(5):
if cb and hasattr(cb,'before_calc'): cb.before_calc(i)
res += i*i
sleep(1)
if cb and hasattr(cb,'after_calc'):
if cb.after_calc(i, res):
print("stopping early")
break
return res
class PrintAfterCallback():
def after_calc (self, epoch, val):
print(f"After {epoch}: {val}")
if val>10: return True
slow_calculation(PrintAfterCallback())
After 0: 0 After 1: 1 After 2: 5 After 3: 14 stopping early
14
class SlowCalculator():
def __init__(self, cb=None): self.cb,self.res = cb,0
def callback(self, cb_name, *args):
if not self.cb: return
cb = getattr(self.cb,cb_name, None)
if cb: return cb(self, *args)
def calc(self):
for i in range(5):
self.callback('before_calc', i)
self.res += i*i
sleep(1)
if self.callback('after_calc', i):
print("stopping early")
break
class ModifyingCallback():
def after_calc (self, calc, epoch):
print(f"After {epoch}: {calc.res}")
if calc.res>10: return True
if calc.res<3: calc.res = calc.res*2
calculator = SlowCalculator(ModifyingCallback())
calculator.calc()
calculator.res
After 0: 0 After 1: 1 After 2: 6 After 3: 15 stopping early
15
__dunder__ thingies¶Anything that looks like __this__ is, in some way, special. Python, or some library, can define some functions that they will call at certain documented times. For instance, when your class is setting up a new object, python will call __init__. These are defined as part of the python data model.
For instance, if python sees +, then it will call the special method __add__. If you try to display an object in Jupyter (or lots of other places in Python) it will call __repr__.
class SloppyAdder():
def __init__(self,o): self.o=o
def __add__(self,b): return SloppyAdder(self.o + b.o + 0.01)
def __repr__(self): return str(self.o)
a = SloppyAdder(1)
b = SloppyAdder(2)
a+b
3.01
Special methods you should probably know about (see data model link above) are:
__getitem____getattr____setattr____del____init____new____enter____exit____len____repr____str____getattr__ and getattr¶class A: a,b=1,2
a = A()
a.b
2
getattr(a, 'b')
2
getattr(a, 'b' if random.random()>0.5 else 'a')
2
class B:
a,b=1,2
def __getattr__(self, k):
if k[0]=='_': raise AttributeError(k)
return f'Hello from {k}'
b = B()
b.a
1
b.foo
'Hello from foo'