Title: Sequence Learning Tasks Author: Thomas Breuel Institution: UniKL
import urllib2
default_n = 29
default_ninput = 2
Here is a number of sequence prediction tasks. For each of them...
def generate_threshold(n=default_n,ninput=default_ninput,threshold=0.5,example=0):
"No temporal dependencies, just threshold of the sum of the inputs."
x = rand(n,ninput)
y = 1.0*(sum(x,axis=1)>threshold*ninput).reshape(n,1)
return x,y
x,y = generate_threshold()
ylim([-.1,1.1]); plot(y,linewidth=3,alpha=0.5); plot(x)
[<matplotlib.lines.Line2D at 0x4da5590>, <matplotlib.lines.Line2D at 0x4da5d50>]
def generate_mod(n=default_n,ninput=default_ninput,m=3,example=0):
"Generate a regular beat every m steps. The input is random."
x = rand(n,ninput)
y = 1.0*(arange(n,dtype='i')%m==0).reshape(n,1)
return x,y
x,y = generate_mod()
ylim([-.1,1.1]); plot(y,linewidth=3,alpha=0.5); plot(x)
[<matplotlib.lines.Line2D at 0x4eda150>, <matplotlib.lines.Line2D at 0x4eda910>]
Generalization:
def generate_imod(n=default_n,ninput=default_ninput,m=3,p=0.2,example=0):
"""Generate an output for every m input pulses."""
if example:
x = array(arange(n)%4==1,'i')
else:
x = array(rand(n)<p,'i')
y = (add.accumulate(x)%m==1)*x*1.0
x = array(vstack([x]*ninput).T,'f')
y = y.reshape(len(y),1)
return x,y
x,y = generate_imod()
ylim([-.1,1.1]); plot(y,linewidth=3,alpha=0.5); plot(x)
[<matplotlib.lines.Line2D at 0x56b9b10>, <matplotlib.lines.Line2D at 0x56be310>]
def generate_smod(n=default_n,ninput=default_ninput,m=3,r=0.5,example=0):
"""Generate an output for every m input pulses. The input
is band limited, so it's a little easier than generate_imod."""
x = rand(n)
x = filters.gaussian_filter(x,r)
x = (x>roll(x,-1))*(x>roll(x,1))
y = (add.accumulate(x)%m==1)*x*1.0
x = array(vstack([x]*ninput).T,'f')
y = y.reshape(len(y),1)
return x,y
x,y = generate_imod()
ylim([-.1,1.1]); plot(y,linewidth=3,alpha=0.5); plot(x)
[<matplotlib.lines.Line2D at 0x5b31c90>, <matplotlib.lines.Line2D at 0x5b35490>]
(sum/product problem)
Input consists of two sequences:
Output:
def generate_anbn(ninput=default_ninput,n=default_n,k=default_n//3,example=0):
"""A simple detector for a^nb^n. Note that this does not
train the network to distinguish this langugage from other languages."""
inputs = zeros(n)
outputs = zeros(n)
if example:
l = n//3
else:
l = 1+int((k-1)*rand())
inputs[:l] = 1
outputs[2*l] = 1
outputs = outputs.reshape(len(outputs),1)
return vstack([inputs]*ninput).T,outputs
x,y = generate_anbn()
ylim([-.1,1.1]); plot(y,linewidth=3,alpha=0.5); plot(x)
[<matplotlib.lines.Line2D at 0x6d2e590>, <matplotlib.lines.Line2D at 0x6d2ed50>]
General symbol coding (input or output)
Other language recognition tasks:
.*A.*B.*
vs .*B.*A.*
imshow(imread("reber.png"),cmap=cm.gray)
<matplotlib.image.AxesImage at 0x78453d0>
What does "learning" actually mean?
Tests may mean one of several things:
Does it generalize?
Claim: LSTM networks learn non-regular languages
Discuss...
def generate_timing(ninput=default_ninput,n=default_n,t=5,example=0):
"""A simple timing related task: output a spike if no spike occurred within
t time steps before."""
x = 0
inputs = []
while x<n:
inputs.append(x)
x += max(1,0.5*t*randn()+t)
inputs = [-999990]+inputs
outputs = []
for i in range(1,len(inputs)):
if inputs[i]-inputs[i-1]>t:
outputs.append(inputs[i])
inputs = inputs[1:]
xs = zeros((n,ninput))
xs[inputs,:] = 1.0
ys = zeros((n,1))
ys[outputs,:] = 1.0
return xs,ys
x,y = generate_timing(n=100)
ylim([-.1,1.1]); plot(y,linewidth=3,alpha=0.5); plot(x)
[<matplotlib.lines.Line2D at 0x6fd56d0>, <matplotlib.lines.Line2D at 0x6fd5e90>]
def generate_revtiming(ninput=default_ninput,n=default_n,t=5,example=0):
"""A simple timing related task: output a spike if no spike occurs within
t time steps after. This cannot be learned using a causal model (it requires
a reverse model)."""
x = 0
inputs = []
while x<n:
inputs.append(x)
x += max(1,0.5*t*randn()+t)
inputs = inputs+[999999]
outputs = []
for i in range(len(inputs)-1):
if inputs[i+1]-inputs[i]>t:
outputs.append(inputs[i])
inputs = inputs[:-1]
xs = zeros((n,ninput))
xs[inputs,:] = 1.0
ys = zeros((n,1))
ys[outputs,:] = 1.0
return xs,ys
x,y = generate_revtiming(n=100)
ylim([-.1,1.1]); plot(y,linewidth=3,alpha=0.5); plot(x)
[<matplotlib.lines.Line2D at 0x711aa10>, <matplotlib.lines.Line2D at 0x711d210>]
def generate_biditiming(ninput=default_ninput,n=default_n,t=5,example=0):
"""Like generate_timing and generate_revtiming combined. Requires
bidirectional training."""
x = 0
inputs = []
while x<n:
inputs.append(x)
x += max(1,0.5*t*randn()+t)
inputs = [-999999]+inputs+[999999]
outputs = []
for i in range(1,len(inputs)-1):
if inputs[i+1]-inputs[i]>=t and inputs[i]-inputs[i-1]>=t:
outputs.append(inputs[i])
inputs = inputs[1:-1]
xs = zeros((n,ninput))
xs[inputs,:] = 1.0
ys = zeros((n,1))
ys[outputs,:] = 1.0
return xs,ys
x,y = generate_biditiming(n=100)
ylim([-.1,1.1]); plot(y,linewidth=3,alpha=0.5); plot(x)
[<matplotlib.lines.Line2D at 0x7354e50>, <matplotlib.lines.Line2D at 0x7359650>]
Other examples: