def numpy_prerun(self, is_raveled, io_usage):
inp = None
out = None
if is_raveled:
if io_usage[0]:
inp = ravel(self.input.mem)
if io_usage[1]:
out = ravel(self.output.mem)
err_input = ravel(self.err_input.mem)
err_output = ravel(self.err_output.mem)
else:
if io_usage[0]:
inp = self.input.mem
if io_usage[1]:
out = self.output.mem
err_input = self.err_input.mem
err_output = self.err_output.mem
if eq_addr(err_input, err_output):
self.err_input.map_write()
else:
self.err_input.map_invalidate()
self.err_output.map_read()
if io_usage[0]:
self.input.map_read()
if io_usage[1]:
self.output.map_read()
return inp, out, err_input, err_output
def numpy_prerun(self, is_raveled, io_usage):
inp = None
out = None
if is_raveled:
if io_usage[0]:
inp = ravel(self.input.mem)
if io_usage[1]:
out = ravel(self.output.mem)
err_input = ravel(self.err_input.mem)
err_output = ravel(self.err_output.mem)
else:
if io_usage[0]:
inp = self.input.mem
if io_usage[1]:
out = self.output.mem
err_input = self.err_input.mem
err_output = self.err_output.mem
if eq_addr(err_input, err_output):
self.err_input.map_write()
else:
self.err_input.map_invalidate()
self.err_output.map_read()
if io_usage[0]:
self.input.map_read()
if io_usage[1]:
self.output.map_read()
return inp, out, err_input, err_output
def numpy_prerun(self, make_raveled, copy_in2out):
if make_raveled:
inp = ravel(self.input.mem)
out = ravel(self.output.mem)
else:
inp = self.input.mem
out = self.output.mem
if eq_addr(inp, out):
self.output.map_write()
else:
self.output.map_invalidate()
self.input.map_read()
if copy_in2out:
numpy.copyto(out, inp)
return inp, out
def numpy_prerun(self, make_raveled, copy_in2out):
if make_raveled:
inp = ravel(self.input.mem)
out = ravel(self.output.mem)
else:
inp = self.input.mem
out = self.output.mem
if eq_addr(inp, out):
self.output.map_write()
else:
self.output.map_invalidate()
self.input.map_read()
if copy_in2out:
numpy.copyto(out, inp)
return inp, out
def numpy_run(self):
if eq_addr(self.err_input.mem, self.err_output.mem):
self.err_output.map_write()
else:
self.err_output.map_read()
self.err_input.map_invalidate()
self.mask.map_read()
numpy.multiply(self.err_output.mem.ravel(), self.mask.mem.ravel(), ravel(self.err_input.mem))
def numpy_run(self):
if eq_addr(self.err_input.mem, self.err_output.mem):
self.err_output.map_write()
else:
self.err_output.map_read()
self.err_input.map_invalidate()
self.mask.map_read()
numpy.multiply(self.err_output.mem.ravel(), self.mask.mem.ravel(),
ravel(self.err_input.mem))
def numpy_run(self):
self.output.map_invalidate()
self.input.map_read()
if not self.forward_mode:
self.mask.map_invalidate()
self.calc_mask()
numpy.multiply(self.input.mem.ravel(), self.mask.mem.ravel(), ravel(self.output.mem))
else:
self.output.mem[:] = self.input.mem
def numpy_run(self):
self.output.map_invalidate()
self.input.map_read()
if not self.forward_mode:
self.mask.map_invalidate()
self.calc_mask()
numpy.multiply(self.input.mem.ravel(), self.mask.mem.ravel(),
ravel(self.output.mem))
else:
self.output.mem[:] = self.input.mem
def numpy_run(self):
self.err_output.map_invalidate()
for vec in self.output, self.max_idx, self.labels:
vec.map_read()
for vec in self.n_err, self.confusion_matrix, self.max_err_output_sum:
vec.map_write()
batch_size = self.batch_size
labels = self.labels.mem
confusion_matrix = self.confusion_matrix.mem
n_ok = 0
n_total = 0
multiplier = 1.0 / batch_size if self.mean else 1.0
for i in range(batch_size): # loop by batch
if labels[i] < 0:
self.err_output.mem[i] = 0.0
continue
output = ravel(self.output[i])
err_output = ravel(self.err_output[i])
max_idx = self.max_idx[i]
confusion_matrix[max_idx, labels[i]] += 1
if max_idx == labels[i]:
n_ok += 1
n_total += 1
# Compute softmax output error gradient
err_output[:] = output[:]
err_output[labels[i]] -= 1.0
err_output *= multiplier
if err_output.dtype in (numpy.complex64, numpy.complex128):
self.max_err_output_sum[0] = max(self.max_err_output_sum[0],
numpy.linalg.norm(err_output))
else:
self.max_err_output_sum[0] = max(
self.max_err_output_sum[0], (numpy.fabs(err_output)).sum())
# Set errors for excessive samples to zero
if batch_size < self.err_output.mem.shape[0]:
self.err_output.mem[batch_size:] = 0.0
self.n_err[0] += batch_size - n_ok
self.n_err[1] += n_total
def numpy_run(self):
self.err_output.map_invalidate()
for vec in self.output, self.max_idx, self.labels:
vec.map_read()
for vec in self.n_err, self.confusion_matrix, self.max_err_output_sum:
vec.map_write()
batch_size = self.batch_size
labels = self.labels.mem
confusion_matrix = self.confusion_matrix.mem
n_ok = 0
n_total = 0
multiplier = 1.0 / batch_size if self.mean else 1.0
for i in range(batch_size): # loop by batch
if labels[i] < 0:
self.err_output.mem[i] = 0.0
continue
output = ravel(self.output[i])
err_output = ravel(self.err_output[i])
max_idx = self.max_idx[i]
confusion_matrix[max_idx, labels[i]] += 1
if max_idx == labels[i]:
n_ok += 1
n_total += 1
# Compute softmax output error gradient
err_output[:] = output[:]
err_output[labels[i]] -= 1.0
err_output *= multiplier
if err_output.dtype in (numpy.complex64, numpy.complex128):
self.max_err_output_sum[0] = max(
self.max_err_output_sum[0], numpy.linalg.norm(err_output))
else:
self.max_err_output_sum[0] = max(
self.max_err_output_sum[0], (numpy.fabs(err_output)).sum())
# Set errors for excessive samples to zero
if batch_size < self.err_output.mem.shape[0]:
self.err_output.mem[batch_size:] = 0.0
self.n_err[0] += batch_size - n_ok
self.n_err[1] += n_total
