def prefixcb(op):
oprd = operand(op)
value = readReg(oprd) if type(oprd) == int else m.read(readRegs(HL))
newvalue = None
if op & 0b11111000 == 0:
newvalue = rlc(value)
elif op & 0b11111000 == 8:
newvalue = rrc(value)
elif op & 0b11111000 == 16:
newvalue = rl(value)
elif op & 0b11111000 == 24:
newvalue = rr(value)
elif op & 0b11111000 == 32:
newvalue = sla(value)
elif op & 0b11111000 == 40:
newvalue = sra(value)
elif op & 0b11111000 == 48:
newvalue = swap(value)
elif op & 0b11111000 == 56:
newvalue = srl(value)
elif op & 0b11000000 == 64:
bit(value, op)
elif op & 0b11000000 == 128:
newvalue = reset(value, op)
elif op & 0b11000000 == 192:
newvalue = gset(value, op)
if newvalue != None:
if type(oprd) == int:
writeReg(oprd, newvalue)
else:
update(0, 8) # additional 8 cycles for writing to (HL)
m.write(readRegs(HL), newvalue)
def loadMemory(self):
memFile = 'history/' + self.game["challenger"] + '.mem'
try:
with open(memFile):
self.mem = memory.load(memFile)
except IOError: # Create it
memory.write(self.mem, memFile)
def loadtoc(change):
assert change == '+' or change == '-'
addr = readRegs(HL)
value = readReg(A)
m.write(addr, value)
if change == '+':
inc16(HL)
elif change == '-':
dec16(HL)
def update(self, cycle):
if cycle - self.last_update > 456:
m.write(LY, (m.read(LY) + 1) % 154)
line = m.read(LY)
self.last_update = cycle - cycle % 456
self.draw_line(line)
if line == 153:
try:
self.queue.get_nowait()
except Exception:
self.queue.put(self.lcd)
def writeMemory(self):
memFile = 'history/' + self.game["challenger"] + '.mem'
memory.write(self.mem, memFile)
def fprop(params):
"""
Forward pass of the NTM.
"""
W = params # aliasing for brevity
xs, hs, ys, ps, ts, os = {}, {}, {}, {}, {}, {}
def l():
"""
Silly utility function that should be called in init.
"""
return [{} for _ in xrange(self.heads)]
rs = l()
k_rs, beta_rs, g_rs, s_rs, gamma_rs = l(),l(),l(),l(),l()
k_ws, beta_ws, g_ws, s_ws, gamma_ws = l(),l(),l(),l(),l()
adds, erases = l(),l()
w_ws, w_rs = l(),l() # read weights and write weights
for idx in range(self.heads):
rs[idx][-1] = self.W['rsInit' + str(idx)] # stores values read from memory
w_ws[idx][-1] = softmax(self.W['w_wsInit' + str(idx)])
w_rs[idx][-1] = softmax(self.W['w_rsInit' + str(idx)])
mems = {} # the state of the memory at every timestep
mems[-1] = self.W['memsInit']
loss = 0
for t in xrange(len(inputs)):
xs[t] = np.reshape(np.array(inputs[t]),inputs[t].shape[::-1])
rsum = 0
for idx in range(self.heads):
rsum = rsum + np.dot(W['rh' + str(idx)], np.reshape(rs[idx][t-1],(self.M,1)))
hs[t] = np.tanh(np.dot(W['xh'], xs[t]) + rsum + W['bh'])
os[t] = np.tanh(np.dot(W['ho'], hs[t]) + W['bo'])
for idx in range(self.heads):
# parameters to the read head
k_rs[idx][t] = np.tanh(np.dot(W['ok_r' + str(idx)],os[t]) + W['bk_r' + str(idx)])
beta_rs[idx][t] = softplus(np.dot(W['obeta_r' + str(idx)],os[t])
+ W['bbeta_r' + str(idx)])
g_rs[idx][t] = sigmoid(np.dot(W['og_r' + str(idx)],os[t]) + W['bg_r' + str(idx)])
s_rs[idx][t] = softmax(np.dot(W['os_r' + str(idx)],os[t]) + W['bs_r' + str(idx)])
gamma_rs[idx][t] = 1 + sigmoid(np.dot(W['ogamma_r' + str(idx)], os[t])
+ W['bgamma_r' + str(idx)])
# parameters to the write head
k_ws[idx][t] = np.tanh(np.dot(W['ok_w' + str(idx)],os[t]) + W['bk_w' + str(idx)])
beta_ws[idx][t] = softplus(np.dot(W['obeta_w' + str(idx)], os[t])
+ W['bbeta_w' + str(idx)])
g_ws[idx][t] = sigmoid(np.dot(W['og_w' + str(idx)],os[t]) + W['bg_w' + str(idx)])
s_ws[idx][t] = softmax(np.dot(W['os_w' + str(idx)],os[t]) + W['bs_w' + str(idx)])
gamma_ws[idx][t] = 1 + sigmoid(np.dot(W['ogamma_w' + str(idx)], os[t])
+ W['bgamma_w' + str(idx)])
# the erase and add vectors
# these are also parameters to the write head
# but they describe "what" is to be written rather than "where"
adds[idx][t] = np.tanh(np.dot(W['oadds' + str(idx)], os[t]) + W['badds' + str(idx)])
erases[idx][t] = sigmoid(np.dot(W['oerases' + str(idx)], os[t]) + W['erases' + str(idx)])
w_ws[idx][t] = addressing.create_weights( k_ws[idx][t]
, beta_ws[idx][t]
, g_ws[idx][t]
, s_ws[idx][t]
, gamma_ws[idx][t]
, w_ws[idx][t-1]
, mems[t-1])
w_rs[idx][t] = addressing.create_weights( k_rs[idx][t]
, beta_rs[idx][t]
, g_rs[idx][t]
, s_rs[idx][t]
, gamma_rs[idx][t]
, w_rs[idx][t-1]
, mems[t-1])
ys[t] = np.dot(W['oy'], os[t]) + W['by']
ps[t] = sigmoid(ys[t])
one = np.ones(ps[t].shape)
ts[t] = np.reshape(np.array(targets[t]),(self.out_size,1))
epsilon = 2**-23 # to prevent log(0)
a = np.multiply(ts[t] , np.log2(ps[t] + epsilon))
b = np.multiply(one - ts[t], np.log2(one-ps[t] + epsilon))
loss = loss - (a + b)
for idx in range(self.heads):
# read from the memory
rs[idx][t] = memory.read(mems[t-1],w_rs[idx][t])
# write into the memory
mems[t] = memory.write(mems[t-1],w_ws[idx][t],erases[idx][t],adds[idx][t])
self.stats = [loss, ps, w_rs, w_ws, adds, erases]
return np.sum(loss)
def fprop(params):
"""
Forward pass of the NTM.
"""
W = params # aliasing for brevity
xs, zhs, hs, ys, ps, ts, zos, os = {}, {}, {}, {}, {}, {}, {}, {}
def l():
"""
Silly utility function that should be called in init.
"""
return [{} for _ in xrange(self.heads)]
rs = l()
zk_rs = l()
k_rs, beta_rs, g_rs, s_rs, gamma_rs = l(),l(),l(),l(),l()
k_ws, beta_ws, g_ws, s_ws, gamma_ws = l(),l(),l(),l(),l()
adds, erases = l(),l()
w_ws, w_rs = l(),l() # read weights and write weights
for idx in range(self.heads):
rs[idx][-1] = self.W['rsInit' + str(idx)] # stores values read from memory
w_ws[idx][-1] = softmax(self.W['w_wsInit' + str(idx)])
w_rs[idx][-1] = softmax(self.W['w_rsInit' + str(idx)])
mems = {} # the state of the memory at every timestep
mems[-1] = self.W['memsInit']
loss = 0
for t in xrange(len(inputs)):
xs[t] = np.reshape(np.array(inputs[t]),inputs[t].shape[::-1])
rsum = 0
for idx in range(self.heads):
rsum = rsum + np.dot(W['rh' + str(idx)], np.reshape(rs[idx][t-1],(self.M,1)))
zhs[t] = np.dot(W['xh'], xs[t]) + rsum + W['bh']
hs[t] = np.tanh(zhs[t])
zos[t] = np.dot(W['ho'], hs[t]) + W['bo']
os[t] = np.tanh(zos[t])
for idx in range(self.heads):
# parameters to the read head
zk_rs[idx][t] =np.dot(W['ok_r' + str(idx)],os[t]) + W['bk_r' + str(idx)]
k_rs[idx][t] = np.tanh(zk_rs[idx][t])
beta_rs[idx][t] = softplus(np.dot(W['obeta_r' + str(idx)],os[t])
+ W['bbeta_r' + str(idx)])
g_rs[idx][t] = sigmoid(np.dot(W['og_r' + str(idx)],os[t]) + W['bg_r' + str(idx)])
s_rs[idx][t] = softmax(np.dot(W['os_r' + str(idx)],os[t]) + W['bs_r' + str(idx)])
gamma_rs[idx][t] = 1 + sigmoid(np.dot(W['ogamma_r' + str(idx)], os[t])
+ W['bgamma_r' + str(idx)])
# parameters to the write head
k_ws[idx][t] = np.tanh(np.dot(W['ok_w' + str(idx)],os[t]) + W['bk_w' + str(idx)])
beta_ws[idx][t] = softplus(np.dot(W['obeta_w' + str(idx)], os[t])
+ W['bbeta_w' + str(idx)])
g_ws[idx][t] = sigmoid(np.dot(W['og_w' + str(idx)],os[t]) + W['bg_w' + str(idx)])
s_ws[idx][t] = softmax(np.dot(W['os_w' + str(idx)],os[t]) + W['bs_w' + str(idx)])
gamma_ws[idx][t] = 1 + sigmoid(np.dot(W['ogamma_w' + str(idx)], os[t])
+ W['bgamma_w' + str(idx)])
# the erase and add vectors
# these are also parameters to the write head
# but they describe "what" is to be written rather than "where"
adds[idx][t] = np.tanh(np.dot(W['oadds' + str(idx)], os[t]) + W['badds' + str(idx)])
erases[idx][t] = sigmoid(np.dot(W['oerases' + str(idx)], os[t]) + W['erases' + str(idx)])
w_ws[idx][t] = addressing.create_weights( k_ws[idx][t]
, beta_ws[idx][t]
, g_ws[idx][t]
, s_ws[idx][t]
, gamma_ws[idx][t]
, w_ws[idx][t-1]
, mems[t-1])
w_rs[idx][t] = addressing.create_weights( k_rs[idx][t]
, beta_rs[idx][t]
, g_rs[idx][t]
, s_rs[idx][t]
, gamma_rs[idx][t]
, w_rs[idx][t-1]
, mems[t-1])
ys[t] = np.dot(W['oy'], os[t]) + W['by']
ps[t] = sigmoid(ys[t])
one = np.ones(ps[t].shape)
ts[t] = np.reshape(np.array(targets[t]),(self.out_size,1))
epsilon = 2**-23 # to prevent log(0)
a = np.multiply(ts[t] , np.log2(ps[t] + epsilon))
b = np.multiply(one - ts[t], np.log2(one-ps[t] + epsilon))
loss = loss - (a + b)
for idx in range(self.heads):
# read from the memory
rs[idx][t] = memory.read(mems[t-1],w_rs[idx][t])
# write into the memory
mems[t] = memory.write(mems[t-1],w_ws[idx][t],erases[idx][t],adds[idx][t])
self.stats = [loss, mems, ps, ys, os, zos, hs, zhs, xs, rs, w_rs, w_ws, adds, erases]
return np.sum(loss)
def pushc(value):
writeRegs(SP, readRegs(SP) - 2)
addr = readRegs(SP)
# BUG: should maybe be the other way around
m.write(addr, value & 255)
m.write(addr + 1, value >> 8)
def decat(regs):
addr = readRegs(regs)
value = m.read(addr) - 1
m.write(addr, value)
update(1, 12, zerocheck=value, n=1, h=((value >> 4) & 1))
def putabs():
ls = m.read(pc + 1)
ms = m.read(pc + 2)
addr = ms << 8 | ls
m.write(addr, readReg(A))
update(3, 16)
def loadfromIO():
addr = 0xFF00 | readReg(C)
m.write(addr, readReg(A))
update(1, 8)
def ldh_ia(value):
addr = 0xFF00 | value
m.write(addr, readReg(A))
update(2, 12)
def loadto(regs, reg):
addr = readRegs(regs)
value = readReg(reg)
m.write(addr, value)
update(1, 8)
def loadiat(regs):
addr = readRegs(regs)
value = m.read(pc + 1)
m.write(addr, value)
update(2, 12)