def __init__(self, nnet_prms_file, labellings_file, logbase=2, only_top=5):
with open(nnet_prms_file, 'rb') as nnet_prms_fp:
nnet_prms = pickle.load(nnet_prms_fp)
nnet_prms['training_params']['BATCH_SZ'] = 1
self.ntwk = NeuralNet(**nnet_prms)
self.tester = self.ntwk.get_data_test_model()
self.ht = nnet_prms['layers'][0][1]['img_sz']
self.logbase = logbase
self.only_top = only_top
self.unichars = LabelToUnicodeConverter(labellings_file)
self.nclasses = nnet_prms['layers'][-1][1]["n_out"]
logi("Network {}".format(self.ntwk))
logi("LogBase {}".format(self.logbase))
logi("OnlyTop {}".format(self.only_top))
class Classifier():
def __init__(self, nnet_prms_file, labellings_file, logbase=2, only_top=5):
with open(nnet_prms_file, 'rb') as nnet_prms_fp:
nnet_prms = pickle.load(nnet_prms_fp)
nnet_prms['training_params']['BATCH_SZ'] = 1
self.ntwk = NeuralNet(**nnet_prms)
self.tester = self.ntwk.get_data_test_model()
self.ht = nnet_prms['layers'][0][1]['img_sz']
self.logbase = logbase
self.only_top = only_top
self.unichars = LabelToUnicodeConverter(labellings_file)
self.nclasses = nnet_prms['layers'][-1][1]["n_out"]
logi("Network {}".format(self.ntwk))
logi("LogBase {}".format(self.logbase))
logi("OnlyTop {}".format(self.only_top))
def __call__(self, scaled_glp):
img = scaled_glp.pix.astype('float32').reshape((1, 1, self.ht, self.ht))
if self.ntwk.takes_aux():
dtopbot = scaled_glp.dtop, scaled_glp.dbot
aux_data = np.array([[dtopbot, dtopbot]], dtype='float32')
logprobs, preds = self.tester(img, aux_data)
else:
logprobs, preds = self.tester(img)
logprobs = logprobs[0]/self.logbase
if self.only_top:
decent = np.argpartition(logprobs, -self.only_top)[-self.only_top:]
if logger.isEnabledFor(logging.INFO):
decent = decent[np.argsort(-logprobs[decent])]
else:
decent = np.arange(self.nclasses)
return [(ch, logprobs[i])
for i in decent
for ch in self.unichars[i]]
class Classifier():
def __init__(self, nnet_prms_file, labellings_file, logbase=2, only_top=5):
with open(nnet_prms_file, 'rb') as nnet_prms_fp:
nnet_prms = pickle.load(nnet_prms_fp)
nnet_prms['training_params']['BATCH_SZ'] = 1
self.ntwk = NeuralNet(**nnet_prms)
self.tester = self.ntwk.get_data_test_model()
self.ht = nnet_prms['layers'][0][1]['img_sz']
self.logbase = logbase
self.only_top = only_top
self.unichars = LabelToUnicodeConverter(labellings_file)
self.nclasses = nnet_prms['layers'][-1][1]["n_out"]
logi("Network {}".format(self.ntwk))
logi("LogBase {}".format(self.logbase))
logi("OnlyTop {}".format(self.only_top))
def __call__(self, scaled_glp):
img = scaled_glp.pix.astype('float32').reshape((1, 1, self.ht, self.ht))
if self.ntwk.takes_aux():
dtopbot = scaled_glp.dtop, scaled_glp.dbot
aux_data = np.array([[dtopbot, dtopbot]], dtype='float32')
logprobs, preds = self.tester(img, aux_data)
else:
logprobs, preds = self.tester(img)
logprobs = logprobs[0]/self.logbase
if self.only_top:
decent = np.argpartition(logprobs, -self.only_top)[-self.only_top:]
if logger.isEnabledFor(logging.INFO):
decent = decent[np.argsort(-logprobs[decent])]
else:
decent = np.arange(self.nclasses)
return [(ch, logprobs[i])
for i in decent
for ch in self.unichars[i]]
def __init__(self, nnet_prms_file, labellings_file, logbase=2, only_top=5):
with open(nnet_prms_file, 'rb') as nnet_prms_fp:
nnet_prms = pickle.load(nnet_prms_fp)
nnet_prms['training_params']['BATCH_SZ'] = 1
self.ntwk = NeuralNet(**nnet_prms)
self.tester = self.ntwk.get_data_test_model()
self.ht = nnet_prms['layers'][0][1]['img_sz']
self.logbase = logbase
self.only_top = only_top
self.unichars = LabelToUnicodeConverter(labellings_file)
self.nclasses = nnet_prms['layers'][-1][1]["n_out"]
logi("Network {}".format(self.ntwk))
logi("LogBase {}".format(self.logbase))
logi("OnlyTop {}".format(self.only_top))
def test_on_network(neural_net_file):
print('Loading network configuration: ', neural_net_file)
with open(neural_net_file, 'rb') as prm_pkl_file:
net_prms = pickle.load(prm_pkl_file)
print('Initializing the network...')
ntwk = NeuralNet(**net_prms)
batch_sz = net_prms['training_params']['BATCH_SZ']
n_batches = n_samples // batch_sz
n_training_batches = int(n_batches *
net_prms['training_params']['TRAIN_ON_FRACTION'])
print('Compiling Test Model...')
tester = ntwk.get_test_model(x, y, aux, preds_feats=True)
print('Classifying images...')
counts = defaultdict(int)
wrongs = defaultdict(int)
errors = defaultdict(lambda: defaultdict(list))
train_test_errs = [0, 0]
for ibatch in range(n_batches):
sym_err_rate, aux_stat, logprobs, predictions = tester(ibatch)
for j in range(batch_sz):
index = ibatch * batch_sz + j
truth = y_data[index]
logprob, guess = logprobs[j], predictions[j]
counts[chars[truth]] += 1
if guess != truth:
train_test_errs[ibatch >= n_training_batches] += 1
wrongs[chars[truth]] += 1
rank_of_truth = sum(logprob > logprob[truth])
prob_of_truth = int(100 * np.exp(logprob[truth]))
prob_of_first = int(100 * np.exp(np.max(logprob)))
errors[chars[truth]][chars[guess]].append(
(index, rank_of_truth, prob_of_truth, prob_of_first))
if ibatch % 200 == 0 or ibatch == n_batches - 1:
print('{} of {} batches. Errors Train:{} Test:{}'.format(
ibatch + 1, n_batches, *train_test_errs))
#if i == 100: break
cum_err_rate = sum(wrongs.values()) / sum(counts.values())
train_test_errs[0] /= n_training_batches * batch_sz
train_test_errs[1] /= (n_batches - n_training_batches) * batch_sz
print("Error Rates Cum:{:.2%} Train:{:.2%} Test:{:.2%}".format(
cum_err_rate, *train_test_errs))
####################### Speed Check
n_time_bathces = 100
print("Checking speed: ", end="")
start = time.time()
for ibatch in range(n_time_bathces):
tester(ibatch)
elapsed = time.time() - start
avg_time = 1000 * elapsed / (n_time_bathces * batch_sz)
print("{:.3f}ms per glyph on {}".format(avg_time, theano.config.device))
return {
"ntwk": ntwk,
"cum_err_rate": cum_err_rate,
"train_test_errs": train_test_errs,
"avg_time": avg_time,
"wrongs": wrongs,
"counts": counts,
"errors": errors,
}
allwts = params['allwts']
############################################# Load Data
print("\nLoading the data ...")
try:
img_sz = layers[0][1]["img_sz"]
except KeyError:
img_sz = layers[0][1]["img_sz"] = 32
pad_width = (img_sz - 32) // 2
trin_x, trin_y = utils.load_pad_info("train", pad_width, 0)
test_x, test_y = utils.load_pad_info("test", pad_width, 0)
############################################# Init Network
params['training_params']['BATCH_SZ'] = batch_sz = 100
ntwk = NeuralNet(**params)
############################################# Read glyphs & classify
coarse = utils.fine_to_coarse
def test_wrapper(tester, truth):
print("Classifying...")
fine_errors = np.zeros((100, 100), dtype="uint")
coarse_errors = np.zeros((20, 20), dtype="uint")
sym_err, bit_err, n = 0., 0., len(truth) // batch_sz
for i in range(n):
symdiff, bitdiff, feats, ypred = tester(i)
sym_err += symdiff
bit_err += bitdiff
def test_on_network(neural_net_file):
print('Loading network configuration: ', neural_net_file)
with open(neural_net_file, 'rb') as prm_pkl_file:
net_prms = pickle.load(prm_pkl_file)
print('Initializing the network...')
ntwk = NeuralNet(**net_prms)
batch_sz = net_prms['training_params']['BATCH_SZ']
n_batches = n_samples // batch_sz
n_training_batches = int(n_batches *
net_prms['training_params']['TRAIN_ON_FRACTION'])
print('Compiling Test Model...')
tester = ntwk.get_test_model(x, y, aux, preds_feats=True)
print('Classifying images...')
counts = defaultdict(int)
wrongs = defaultdict(int)
errors = defaultdict(lambda: defaultdict(list))
train_test_errs = [0, 0]
for ibatch in range(n_batches):
sym_err_rate, aux_stat, logprobs, predictions = tester(ibatch)
for j in range(batch_sz):
index = ibatch * batch_sz + j
truth = y_data[index]
logprob, guess = logprobs[j], predictions[j]
counts[chars[truth]] += 1
if guess != truth:
train_test_errs[ibatch >= n_training_batches] += 1
wrongs[chars[truth]] += 1
rank_of_truth = sum(logprob > logprob[truth])
prob_of_truth = int(100 * np.exp(logprob[truth]))
prob_of_first = int(100 * np.exp(np.max(logprob)))
errors[chars[truth]][chars[guess]].append(
(index, rank_of_truth, prob_of_truth, prob_of_first))
if ibatch % 200 == 0 or ibatch == n_batches - 1:
print('{} of {} batches. Errors Train:{} Test:{}'.format(
ibatch + 1, n_batches, *train_test_errs))
#if i == 100: break
cum_err_rate = sum(wrongs.values()) / sum(counts.values())
train_test_errs[0] /= n_training_batches * batch_sz
train_test_errs[1] /= (n_batches - n_training_batches) * batch_sz
print("Error Rates Cum:{:.2%} Train:{:.2%} Test:{:.2%}".format(
cum_err_rate, *train_test_errs))
####################### Speed Check
n_time_bathces = 100
print("Checking speed: ", end="")
start = time.time()
for ibatch in range(n_time_bathces):
tester(ibatch)
elapsed = time.time() - start
avg_time = 1000 * elapsed / (n_time_bathces * batch_sz)
print("{:.3f}ms per glyph on {}".format(avg_time, theano.config.device))
return {"ntwk": ntwk,
"cum_err_rate": cum_err_rate,
"train_test_errs": train_test_errs,
"avg_time": avg_time,
"wrongs": wrongs,
"counts": counts,
"errors": errors, }
allwts = params["allwts"]
############################################# Load Data
print("\nLoading the data ...")
try:
img_sz = layers[0][1]["img_sz"]
except KeyError:
img_sz = layers[0][1]["img_sz"] = 32
pad_width = (img_sz - 32) // 2
trin_x, trin_y = utils.load_pad_info("train", pad_width, 0)
test_x, test_y = utils.load_pad_info("test", pad_width, 0)
############################################# Init Network
params["training_params"]["BATCH_SZ"] = batch_sz = 100
ntwk = NeuralNet(**params)
############################################# Read glyphs & classify
coarse = utils.fine_to_coarse
def test_wrapper(tester, truth):
print("Classifying...")
fine_errors = np.zeros((100, 100), dtype="uint")
coarse_errors = np.zeros((20, 20), dtype="uint")
sym_err, bit_err, n = 0.0, 0.0, len(truth) // batch_sz
for i in range(n):
symdiff, bitdiff, feats, ypred = tester(i)
sym_err += symdiff
bit_err += bitdiff
with open(nnet_prms_file_name, 'rb') as nnet_prms_file:
nnet_prms = pickle.load(nnet_prms_file)
with open(labelings_file_name, encoding='utf-8') as labels_fp:
labellings = ast.literal_eval(labels_fp.read())
# print(labellings)
chars = LabelToUnicodeConverter(labellings).onecode
############################################# Init Network
Bantry.scaler = ScalerFactory(scaler_prms)
bf = BantryFile(banti_file_name)
nnet_prms['training_params']['BATCH_SZ'] = 1
ntwk = NeuralNet(**nnet_prms)
tester = ntwk.get_data_test_model(go_nuts=True)
############################################# Image saver
dir_name = os.path.basename(nnet_prms_file_name)[:-7] + '/'
if not os.path.exists(dir_name):
os.makedirs(dir_name)
namer = (dir_name + '{:03d}_{}_{:02d}.png').format
print("Look for me in :", dir_name)
def saver(outs, ch, debug=True):
saver.index += 1
for i, out in enumerate(outs):
global_normalize = False
if out.ndim == 2:
n_nodes = out.shape[1]
############################################# Load Data
print("\nLoading the data ...")
try:
img_sz = layers[0][1]["img_sz"]
except KeyError:
img_sz = layers[0][1]["img_sz"] = 32
pad_width = (img_sz-32)//2
#trin_x, trin_y = utils.load_pad_info("train", pad_width, 0)
test_x, test_y = utils.load_pad_info("test", pad_width, 0)
test_col = (np.rollaxis(test_x, 1, 4)*255).astype("uint8")
############################################# Init Network
params['training_params']['BATCH_SZ'] = 1
ntwk = NeuralNet(**params)
tester = ntwk.get_data_test_model(go_nuts=True)
############################################# Image saver
dir_name = os.path.basename(nnet_prms_file_name)[:-4] + '/'
if not os.path.exists(dir_name):
os.makedirs(dir_name)
namer = (dir_name + '{}_{:02d}.png').format
# Usage:namer(info, i)
def saver(outs, info, debug=True):
for i, out in enumerate(outs):
global_normalize = False
if out.ndim == 2:
n_nodes = out.shape[1]
trin_x = share(data_x[:n_train, ])
test_x = share(data_x[n_train:, ])
trin_y = share(data_y[:n_train, ], 'int32')
test_y = share(data_y[n_train:, ], 'int32')
if aux_file_name:
data_aux = read_json_bz2(aux_file_name)
#Can normalize the aux data by division /layers[0][1]['img_sz']
trin_aux = share(data_aux[:n_train, ])
test_aux = share(data_aux[n_train:, ])
else:
trin_aux, test_aux = None, None
print("\nInitializing the net ... ")
nn = NeuralNet(layers, tr_prms, allwts)
print(nn)
print("\nCompiling ... ")
training_fn = nn.get_trin_model(trin_x, trin_y, trin_aux)
test_fn_tr = nn.get_test_model(trin_x, trin_y, trin_aux)
test_fn_te = nn.get_test_model(test_x, test_y, test_aux)
tr_corpus_sz = n_train
te_corpus_sz = corpus_sz - n_train
nEpochs = tr_prms['NUM_EPOCHS']
nTrBatches = tr_corpus_sz // batch_sz
nTeBatches = te_corpus_sz // batch_sz
############################################## MORE HELPERS
