def teste(arquivo):
with open('BLSTM.pkl', 'rb') as pkl_file:
layer2, layer1, image = dill.load(pkl_file)
audio = retorna_logfbank(arquivo)
dados_carregado = cd.Carrega()
chars = utils.mapeamento_palavra()
printer = utils.Printer(chars)
data_x = []
_, sinal = aux.deslocamento_amostra(audio, larg=largura)
sinal = np.concatenate(sinal)
probs = dados_carregado.treinar(sinal)
data_x.append(np.asarray(probs.T, dtype=th.config.floatX))
ntwk = neuralNetTest(layer2, layer1, image)
x = data_x[0]
saida_obtida, _ = ntwk.tester(x)
rotulo_pred, retornado2 = printer.rotulo_(saida_obtida)
resultado = verificar(retornado2)
print("Palavra encontrada:", resultado)
return resultado
def testar(ntwk, rodada, dados_carregado, largura):
with open('base_BF_rod' + str(rodada) + '.pkl', 'rb') as f:
base = dill.load(f)
lista, y_train = base[0], base[2]
args = utils.read_args('configs/default.ast')
num_epochs, nnet_args = args['num_epochs'], args['nnet_args']
chars = utils.mapeamento_palavra()
num_classes = len(chars)
num_samples = len(lista)
printer = utils.Printer(chars)
data_x, data_y = formata_padrao_entrada_saida(num_classes, y_train,
dados_carregado, lista,
largura)
img_ht = data_x[0].shape[0]
acertos = 0
erros = 0
quantidade_total = len(lista)
for c in range(1):
for i in range(len(lista)):
# print(lista[i])
x = data_x[i]
y = data_y[i]
_, esperado = printer.yprint2(y)
saida_obtida, _ = ntwk.tester(x)
rotulo_pred, retornado2 = printer.rotulo_(saida_obtida)
resultado = verificar(retornado2)
if (esperado == resultado):
acertos += 1
else:
erros += 1
return acertos, erros
output_fname = output_fname.replace('.ast', '').replace('/', '').replace('configs', '')
else:
output_fname = "default"
network_fname = '{}.pkl'.format(output_fname)
output_fname += '_' + dt.now().strftime('%y%m%d_%H%M') + '.txt'
distances, wts = [], []
print("Output will be written to: ", output_fname)
# Initialize Language
lang.select_labeler(args['labeler'])
alphabet_size = len(lang.symbols)
# Initialize Scriber
scribe_args['dtype'] = th.config.floatX
scriber = Scribe(lang, **scribe_args)
printer = utils.Printer(lang.symbols)
sys.setrecursionlimit(1000000)
# Initialize the Neural Network
if os.path.exists(network_fname):
print('Loading existing network file')
with open(network_fname, 'rb') as fh:
ntwk = pickle.load(fh)
else:
print('Building the Network')
ntwk = nn.NeuralNet(scriber.height, alphabet_size, **nnet_args)
with open(network_fname, 'wb') as fh:
pickle.dump(ntwk, fh)
################################### Main Script ###########################
print('Loading the dataset.')
with open(sys.argv[1], 'rb') as pkl_file:
data = pickle.load(pkl_file)
args = utils.read_args(sys.argv[2:])
num_epochs, train_on_fraction = args['num_epochs'], args['train_on_fraction']
scribe_args, nnet_args, = args['scribe_args'], args['nnet_args'],
chars = data['chars']
num_classes = len(chars)
img_ht = len(data['x'][0])
num_samples = len(data['x'])
nTrainSamples = int(num_samples * train_on_fraction)
printer = utils.Printer(chars)
print('\nInput Dim: {}'
'\nNum Classes: {}'
'\nNum Samples: {}'
'\nNum Epochs: {}'
'\nFloatX: {}'
'\n'.format(img_ht, num_classes, num_samples, num_epochs,
th.config.floatX))
################################
print('Preparing the Data')
try:
conv_sz = nnet_args['midlayerargs']['conv_sz']
except KeyError:
conv_sz = 1
import nnet.neuralnet as nn
from scribe.scribe import Scribe
################################ Initialize
args = utils.read_args(sys.argv[1:])
num_samples, num_epochs = args['num_samples'], args['num_epochs']
scribe_args, nnet_args = args['scribe_args'], args['nnet_args']
print('\nArguments:'
'\nFloatX : {}'
'\nNum Epochs : {}'
'\nNum Samples : {}'
'\n'.format(th.config.floatX, num_epochs, num_samples))
scriber = Scribe(**scribe_args)
printer = utils.Printer(scriber.alphabet.chars)
print(scriber)
print('Building the Network')
ntwk = nn.NeuralNet(scriber.nDims, scriber.nClasses, **nnet_args)
print(ntwk)
################################
print('Training the Network')
for epoch in range(num_epochs):
ntwk.update_learning_rate(epoch)
for samp in range(num_samples):
x, y1 = scriber.get_sample()
if len(y1) < 2: