def next_batch(self, batch_size):
if self._start_idx + batch_size > self.num_samples:
self._start_idx = 0
self.file_change = True
self._num_file += 1
# print("EOF : " + self._name + " file_" + str(self._num_file-1).zfill(2) +
# " -> BOF : " + self._name + " file_" + str(self._num_file).zfill(2))
if self._num_file > self._file_len - 1:
self.eof = True
self._num_file = 0
# print("EOF : last " + self._name + " file. " + "-> BOF : " + self._name + " file_" +
# str(self._num_file).zfill(2))
self._inputs = self._read_input(
self._input_file_list[self._num_file],
self._input_spec_list[self._num_file])
self._outputs = self._read_output(
self._output_file_list[self._num_file])
data_len = np.shape(self._inputs)[0]
self._outputs = self._outputs[0:data_len, :]
assert np.shape(self._inputs)[0] == np.shape(self._outputs)[0], \
("# samples is not matched between input: %d and output: %d files"
% (np.shape(self._inputs)[0], np.shape(self._outputs)[0]))
self.num_samples = np.shape(self._outputs)[0]
else:
self.file_change = False
self.eof = False
inputs = self._inputs[self._start_idx:self._start_idx + batch_size, :]
self.raw_inputs = inputs # adding part
inputs = self.normalize(inputs)
inputs = utils.bdnn_transform(inputs, self._w, self._u)
# inputs = inputs[self._w: (batch_size-self._w), :]
outputs = self._outputs[self._start_idx:self._start_idx +
batch_size, :]
outputs = utils.bdnn_transform(outputs, self._w, self._u)
# outputs = outputs[self._w: (batch_size - self._w), :]
self._start_idx += batch_size
return inputs, outputs
def next_batch(self, batch_size):
if self._start_idx + batch_size > self.num_samples:
self._start_idx = 0
self._num_file += 1
print("EOF : " + self._name + " file_" +
str(self._num_file - 1).zfill(2) + " -> BOF : " +
self._name + " file_" + str(self._num_file).zfill(2))
if self._num_file > self._file_len - 1:
self.eof = True
self._num_file = 0
print("EOF : last " + self._name + " file. " + "-> BOF : " +
self._name + " file_" + str(self._num_file).zfill(2))
self._inputs = self._read_input(
self._input_file_list[self._num_file],
self._input_spec_list[self._num_file])
self._outputs = self._read_output(
self._output_file_list[self._num_file])
data_len = np.shape(self._inputs)[0]
self._outputs = self._outputs[0:data_len, :]
assert np.shape(self._inputs)[0] == np.shape(self._outputs)[0], \
("# samples is not matched between input: %d and output: %d files"
% (np.shape(self._inputs)[0], np.shape(self._outputs)[0]))
self.num_samples = np.shape(self._outputs)[0]
# print("current file number : %d, samples : %d" % (self._num_file + 1, self.num_samples))
#print("Loaded " + self._name + " file number : %d" % (self._num_file + 1))
inputs = self._inputs[self._start_idx:self._start_idx + batch_size, :]
inputs = self.normalize(inputs)
inputs = utils.bdnn_transform(inputs, self._w, self._u)
inputs = inputs[self._w:(batch_size - self._w), :]
outputs = self._outputs[self._start_idx:self._start_idx +
batch_size, :]
# if valid:
# plt.figure(self._num_figure)
# self._num_figure += 1
# bb = np.zeros(aa.shape)
# bb[:, 200:250] = outputs*10
#
# cc = aa + bb
# imgplot = plt.imshow(cc.T)
# plt.show()
outputs = outputs[self._w:(batch_size - self._w), :]
self._start_idx += batch_size
# print(self._start_idx)
# print(self.num_samples)
return inputs, outputs
def next_batch(self, batch_size):
self._inputs = self._read_input(self._input_file_list[self._num_file])
self._outputs = self._read_output(self._output_file_list[self._num_file])
assert np.shape(self._inputs)[0] == np.shape(self._outputs)[0], \
("# samples is not matched between input: %d and output: %d files"
% (np.shape(self._inputs)[0], np.shape(self._outputs)[0]))
self.num_samples = np.shape(self._outputs)[0]
self._start_idx = self._w
self.file_change = True
self._num_file += 1
if self._num_file > self._file_len - 1:
self.eof = True
self._num_file = 0
# self._inputs = self._read_input(self._input_file_list[self._num_file],self._input_spec_list[self._num_file])
# self._outputs = self._read_output(self._output_file_list[self._num_file])
data_len = np.shape(self._inputs)[0]
self._outputs = self._outputs[0:data_len, :]
assert np.shape(self._inputs)[0] == np.shape(self._outputs)[0], \
("# samples is not matched between input: %d and output: %d files"
% (np.shape(self._inputs)[0], np.shape(self._outputs)[0]))
self.num_samples = np.shape(self._outputs)[0]
inputs = self._inputs
self.raw_inputs = inputs # adding part
inputs = self.normalize(inputs)
inputs = utils.bdnn_transform(inputs, self._w, self._u)
# inputs = inputs[self._w: -self._w, :]
outputs = self._outputs
outputs = utils.bdnn_transform(outputs, self._w, self._u)
# outputs = outputs[self._w: -self._w, :]
# self._start_idx += batch_size
return inputs, outputs
def next_batch(self, batch_size):
self._inputs = self._padding(self.X_train[self._start_idx:self._start_idx+batch_size], batch_size, self._w)
self._outputs = self._padding(self.y_train[self._start_idx:self._start_idx+batch_size], batch_size, self._w)
self.num_samples = np.shape(self._outputs)[0]
inputs = self._inputs[self._start_idx - self._w:self._start_idx + batch_size + self._w, :]
inputs = utils.bdnn_transform(inputs, self._w, self._u)
inputs = inputs[self._w: -self._w, :]
outputs = self._outputs[self._start_idx - self._w:self._start_idx + batch_size + self._w, :]
outputs = utils.bdnn_transform(outputs, self._w, self._u)
outputs = outputs[self._w: -self._w, :]
self._start_idx += batch_size
if self._start_idx+batch_size > self.X_train.shape[0]:
self._start_idx = 0
return inputs, outputs
def bdnn_prediction(bdnn_batch_size, logits, threshold=th):
result = np.zeros((bdnn_batch_size, 1))
indx = np.arange(bdnn_batch_size) + 1
indx = indx.reshape((bdnn_batch_size, 1))
indx = utils.bdnn_transform(indx, w, u)
indx = indx[w:(bdnn_batch_size - w), :]
indx_list = np.arange(w, bdnn_batch_size - w)
for i in indx_list:
indx_temp = np.where((indx - 1) == i)
pred = logits[indx_temp]
pred = np.sum(pred) / pred.shape[0]
result[i] = pred
result = np.trim_zeros(result)
result = result >= threshold
return result.astype(int)
def bdnn_prediction(batch_size, logits, threshold=0.6, w=19, u=9):
bdnn_batch_size = batch_size + 2 * w
result = np.zeros((bdnn_batch_size, 1))
indx = np.arange(bdnn_batch_size) + 1
indx = indx.reshape((bdnn_batch_size, 1))
indx = utils.bdnn_transform(indx, w, u)
indx = indx[w:(bdnn_batch_size - w), :]
indx_list = np.arange(w, bdnn_batch_size - w)
for i in indx_list:
indx_temp = np.where((indx - 1) == i)
pred = logits[indx_temp]
pred = np.sum(pred) / pred.shape[0]
result[i] = pred + np.random.rand(1) * 1e-4
result = np.trim_zeros(result)
soft_result = np.float32(result)
result = result >= threshold
return result.astype(int), soft_result
def bdnn_prediction(batch_size_in, logits, threshold=th):
bdnn_batch_size = batch_size_in + 2 * w
result = np.zeros((int(bdnn_batch_size), 1))
indx = np.arange(int(bdnn_batch_size)) + 1
indx = indx.reshape((int(bdnn_batch_size), 1))
indx = utils.bdnn_transform(indx, w, u)
indx = indx[w:(int(bdnn_batch_size) - w), :]
indx_list = np.arange(w, int(bdnn_batch_size) - w)
for i in indx_list:
indx_temp = np.where((indx - 1) == i)
pred = logits[indx_temp]
pred = np.sum(pred) / pred.shape[0]
result[i] = pred
result = np.trim_zeros(result)
soft_result = np.float32(result)
result = np.float32(result) >= threshold
return result.astype(np.float32), soft_result
import numpy as np
import utils
a = np.arange(12) + 1
a = a.reshape((-1, 3))
bb = utils.bdnn_transform(a, 2, 1)
for i in range(bb.shape[0]):
print(bb[i, :])
batch_size = 20 idx = np.arange(batch_size) + 1 idx = np.reshape(idx, (batch_size, 1)) data = np.arange(batch_size * 3) - 1 data = np.reshape(data, (batch_size, 3)) label = np.arange(batch_size) + 10 label = label.reshape((batch_size, 1)) w = 5 u = 2 trans_idx = utils.bdnn_transform(idx, w, u) trans_data = utils.bdnn_transform(data, w, u) trans_label = utils.bdnn_transform(label, w, u) result = np.zeros((batch_size, 1)) final_data = trans_data[w:(batch_size - w), :] numm = np.arange(w, batch_size - w) # for i in numm: # idx_temp = np.where((trans_idx-1) == i) # aa = trans_label[idx_temp] # aa = np.sum(aa)/aa.shape[0] # result[i] = aa
