def train_fine(new_text, generic_weights, save_file):
with open(new_text) as f:
s = f.read()
model = get_basic_model(freeze_feature_layers=True)
model.load_weights(generic_weights)
fine_model = train(s, model, save_file)
return fine_model
def evaluate_4way(known_file, unknown_file, generic_model, fine_weights):
fine_model = get_basic_model()
fine_model.load_weights(fine_weights)
known_fine = evaluate(known_file, fine_model)
unknown_fine = evaluate(unknown_file, fine_model)
known_gen = evaluate(known_file, generic_model)
unknown_gen = evaluate(unknown_file, generic_model)
return known_gen, unknown_gen, known_fine, unknown_fine
def main():
weightsfile = sys.argv[1]
textfile = sys.argv[2]
model = get_basic_model(freeze_feature_layers=True)
model.load_weights(weightsfile)
with open(textfile) as f:
s = f.read()
X, y = text2vec(s)
print(model.evaluate(X, y))
def main():
directory = sys.argv[1]
generic_w = sys.argv[2]
generic_model = get_basic_model()
generic_model.load_weights(generic_w)
authors = [x for x in os.listdir(directory) if x.startswith("EN")]
scores = {}
for author in authors:
print("working on {}".format(author))
known = os.path.join(directory, author, "known01.txt")
unknown = os.path.join(directory, author, "unknown.txt")
known_weights = os.path.join(directory, author, "knownmodel.h5")
kg, ug, kf, uf = evaluate_4way(known, unknown, generic_model,
known_weights)
scores[author] = (kg, ug, kf, uf)
print("author: {} kg: {}, ug: {}, kf: {}, uf: {}".format(
author, kg, ug, kf, uf))
print(scores)
with open("scores.txt", "w") as f:
for author in scores:
f.write("{}: {}".format(author, scores[author]))
weightsfile = sys.argv[2]
with open(seedfile) as f:
s = f.read()
s = ''.join(list(filter(lambda x: x in ALPHABET, s)))
print("vectorizing seed...")
dataX = []
dataY = []
for i in range(len(s) - seq_length):
seq_in = s[i:i + seq_length]
seq_out = s[i + seq_length]
dataX.append([c2i(char) for char in seq_in])
dataY.append(c2i(seq_out))
print("building model...")
model = get_basic_model()
model.load_weights(weightsfile)
start = numpy.random.randint(0, len(dataX) - 1)
print("making predictions...")
pattern = dataX[start]
last_pred = None
num_reps = 0
for i in range(1000):
x = numpy.reshape(pattern, (1, len(pattern), 1))
x = x / float(len(ALPHABET))
prediction = model.predict(x, verbose=0)
index = numpy.argmax(prediction)
if random.randrange(0, 2) == 1:
prediction = numpy.delete(prediction, index)
index = numpy.argmax(prediction)
def train_fine(person_file, weightsfile, save_file="model_weights_person.h5"):
with open(person_file) as f:
s = f.read()
model = get_basic_model(freeze_feature_layers=True)
model.load_weights(weightsfile)
train(s, model, save_file)
def train_generic(corpus_file, save_file="model_weights_generic.h5"):
with open(corpus_file) as f:
s = f.read()
model = get_basic_model()
train(s, model, save_file)
