def train_data (inputFile, outputDir):
sess = gpt2.start_tf_sess()
# train for the input file
# tf.variable_scope("sess", reuse=True)
'''
gpt2.finetune(sess,
"resource/"+inputFile+".txt",
model_name=model_name,
#run_name=inputFile,
overwrite=True,
steps=2)
#_traceback = tf_stack.extract_stack()) # steps is max number of training steps '''
# generate 50 examples
for x in range(0,10):
# tf.get_variable_scope().reuse_variables()
gpt2.load_gpt2(sess)
# output = gpt2.generate(sess, return_as_list=True)[0]
gpt2.generate_to_file(sess, destination_path="newoutputs/" +outputDir+str(uuid.uuid4())+".txt")
# datalist = gpt2.generate(sess, return_as_list=True)[0]
# print (datalist)
# gen_to_file(outputDir, inputFile)
# tf.get_variable_scope(reuse=True)
#tf.get_variable_scope().reuse_variables()
# tf.get_variable_scope(reuse=True)
# tf.AUTO_REUSE = True
# sess.reuse_variables()
# tf.reset_default_graph()
gpt2.reset_session(sess,threads=-1,server=None)
'''
def train(input_file):
if os.path.exists('models/temp'):
shutil.rmtree('models/temp')
if os.path.exists('models/124M'):
pass
else:
download()
sess = gpt2.start_tf_sess()
model_name = '124M'
model_dir = 'models/'
training_dir = 'src/training_data/'
file_name = input_file.split('.')[0]
gpt2.finetune(sess,
training_dir+input_file,
model_name=model_name,
checkpoint_dir=model_dir+'temp/',
run_name='',
steps=1)
gpt2.reset_session(sess)
if os.path.exists('models/latest'):
shutil.rmtree('models/latest')
shutil.copytree('models/temp','models/latest')
# shutil.rmtree('models/temp')
def fine_tune(self, steps=100):
self.download_tuning()
self.log_function(f"* Fine tuning towards {self.tuning_description}...")
brain = gpt2.start_tf_sess()
gpt2.finetune(
brain, self.tuning_path,
model_name=self.model_name, steps=steps, run_name=self.run_name, overwrite=True
)
gpt2.reset_session(brain)
def generate(self, prefix="I once", length=100):
self.log_function("* Generating text...")
self.log_function(f" * {self.model_description} language model tuned towards {self.tuning_description}.")
brain = gpt2.start_tf_sess()
run_name = self.run_name if os.path.isdir(os.path.join("checkpoint", self.run_name)) else None
model_name = None if os.path.isdir(os.path.join("checkpoint", self.run_name)) else self.model_name
gpt2.load_gpt2(brain, run_name=run_name, model_name=model_name)
text = gpt2.generate(
brain,
prefix=prefix, length=length, run_name=run_name, return_as_list=True, model_name=self.model_name,
)[0]
gpt2.reset_session(brain)
return text
async def homepage(request):
global generate_count
global sess
if request.method == 'GET':
params = request.query_params
elif request.method == 'POST':
params = await request.json()
elif request.method == 'HEAD':
return UJSONResponse({'text': ''},
headers=response_header)
gpt2.load_gpt2(sess, run_name=params.get('run_name', ''))
text = gpt2.generate(sess,
run_name=params.get('run_name', ''),
length=int(params.get('length', 1023)),
temperature=float(params.get('temperature', 0.7)),
top_k=int(params.get('top_k', 0)),
top_p=float(params.get('top_p', 0)),
prefix=params.get('prefix', '')[:500],
truncate=params.get('truncate', None),
include_prefix=str(params.get('include_prefix', True)).lower() == 'true',
return_as_list=True)[0]
sess = gpt2.reset_session(sess)
gc.collect()
return UJSONResponse({'text': text},
headers=response_header)
def generate_new(self, origin, vals):
#return ('stuff ' + str(random.randrange(10000))).encode('utf-8')
dir = model_dir(origin)
if dir != self.last_model:
self.sess = gpt2.reset_session(self.sess, threads=7)
gpt2.load_gpt2(self.sess, checkpoint_dir=dir)
self.last_model = dir
if self.last_model == BB_DIR:
prompt = '<|startoftext|> '+ vals['title'] + ' - Breitbart <START> '
else:
prompt = vals['title'] + ' <START> '
text = gpt2.generate(self.sess, checkpoint_dir=self.last_model, return_as_list=True, prefix=prompt,
include_prefix=False, truncate='<|endoftext|>')[0]
if self.last_model == BB_DIR:
text = text.replace('[', '</p> <p class="zn-body__paragraph">')
text = str.encode(text)
return text
def __init__(self, client):
"""
Read the config from the file at the path CONFIG_PATH, if the config file is not in the expected format or
contains a config that isn't recognised, the config is loaded from the dictionary DEFAULT_CONFIG.
Initialise a TensorFlow session for gpt2 then load the GPT2 model as determined by the config.
NOTE: If the config is modified after the DEFAULT_CONFIG has been loaded it, it will be overwritten.
"""
self.client = client
self.config = {}
self.load_config(False)
self.default_prompts = read_default_prompts()
self.sess = gpt2.start_tf_sess()
try:
gpt2.load_gpt2(self.sess, model_name=self.config['model_name'])
except ValueError:
self.sess = gpt2.reset_session(self.sess)
gpt2.load_gpt2(self.sess, model_name=self.config['model_name'])
def sample():
version = request.args.get('version')
length = int(request.args.get('length'))
prompt = request.args.get('prompt')
nsamples = int(request.args.get('nsamples'))
global curr_version
global sess
if version != curr_version and version != '':
sess = gpt2.reset_session(sess)
gpt2.load_gpt2(sess, checkpoint_dir="/opt/app/checkpoint", run_name=version)
curr_version = version
out = gpt2.generate(sess, nsamples=nsamples, prefix=prompt, top_k=0, return_as_list=True,checkpoint_dir="/opt/app/checkpoint", run_name=curr_version, length=length)
result = ""
for i in range(nsamples):
result += "======== SAMPLE " + str(i+1) + " ========\n"
result += out[i] + "\n"
return jsonify({"sample" : result})
def buildResponse(self):
global sess
global responses
global sessCritical
global workQueue
responses=responses+1
workQueue=workQueue+1
rawresponse = gpt2.generate(sess, prefix=self.grabText(), include_prefix=False, length=75, return_as_list=True)
workQueue=workQueue-1
# if we've used the model 5 times and we're not currently using it, reset the model to free up memory!
if responses > trigger_collect and workQueue <= 0:
sessCritical = True
print("=========FREEING MEMORY=========")
sess = gpt2.reset_session(sess)
gpt2.load_gpt2(sess)
responses = 0
sessCritical = False
print(rawresponse)
chats = rawresponse[0].split('\n')
return self.getUnique(chats)
def attempt_generate(sess=None):
with open('config.json') as f:
config = json.load(f)
if not sess:
sess = gpt2.start_tf_sess()
else:
sess = gpt2.reset_session(sess)
gpt2.load_gpt2(sess, run_name=config['run_name'])
file_core = 'motivational_quotes'
time_string = datetime.now().strftime('%d-%m-%Y_%H-%M-%S')
model_type = config['model']
output_file = f'{file_core}_{model_type}.txt'
gpt2.generate(sess,
top_k=40,
run_name=config['run_name'],
nsamples=config['samples_to_generate'],
destination_path=config['model_output_path'] + output_file)
return sess
def reset_model(model, step_count, checkpoint_directory='checkpoint'):
global tf_session
if step_count % 10 == 0:
tf_session = gpt2.reset_session(sess=tf_session)
load_model(model, checkpoint_directory)
def generate_trending_tweet():
topics = ["Biden", "Trump"]
topic = choice(topics)
# this is just for testing repeat topics- remove before deployment
print("generating topical tweets on subject: " + topic)
# update the text file with current tweets
file_name = '../data/'+topic+'.txt'
topical_tweets = get_topic_tweets(topic, 5000)
t_tweet_string = " || ".join(topical_tweets)
with open(file_name, 'w') as f:
f.write(t_tweet_string)
# train model
print("training new model on scraped text for topic : "+topic)
sess = gpt2.start_tf_sess()
if not os.path.exists('checkpoint/'+topic):
# train fresh model
print("training fresh model- none found...")
gpt2.finetune(sess,
dataset=file_name,
model_name=model_name,
steps=200,
restore_from='fresh',
run_name=topic,
print_every=1)
else:
# update existing model
print("updating existing model with short run on new tweets...")
gpt2.finetune(sess,
dataset=file_name,
model_name=model_name,
run_name=topic,
steps=100,
restore_from='latest',
print_every=1)
# generate tweet
print("beginning to generate tweets...")
gpt2.generate_to_file(sess,
length=400,
destination_path='../data/generated_tweets.txt',
nsamples=10,
run_name=topic,
prefix=topic)
print('done generating tweets... ')
# reset the session to prevent errors on loop
gpt2.reset_session(sess=sess)
# return 1 tweet
with open('../data/generated_tweets.txt', 'r') as f:
texts = f.read().split('====================')
tweets = []
for text in texts:
# by just taking the first tweet, we're sure we have the seed text
tweeters = text.split(' || ')
for tweet in tweeters:
if topic in tweet: # ensure it contains the topic string
tweet = tweet.split(" ")
# remove links
tweet = " ".join(
word for word in tweet if not has_prefix(word))
# ensure it's not just the topic word only
if len(tweet) > len(topic)+4 & len(tweet) <= 280:
tweets.append(tweet)
else:
continue
#print("Potential tweets:\n"+ " \n\n ".join(tweets))
tweet = choice(tweets)
if len(tweet) > 280:
tweet = tweet[:280]
return tweet
lines = []
for i in range(0, height):
lines.append('')
return lines
sess = None
for ii in range(0, generate_count):
print(ii)
if not sess:
sess = gpt2.start_tf_sess()
else:
sess = gpt2.reset_session(sess)
gpt2.load_gpt2(sess, run_name=run_name)
lines = blankLines()
prefix = ''
hasColor = False
while True:
text = gpt2.generate(sess, run_name=run_name, prefix=prefix, temperature=temperature, return_as_list=True)[0]
print('\n\noutput:')
print(text)
newLines = text.split('\n')
def function_generate(hparams, saved_dir):
sess = gpt2.start_tf_sess()
sess = gpt2.reset_session(sess)
# determine the generate model to use
if hparams.use_nisl_model == 1:
info_print('The NISL model is selected.')
generate_model_dir = '/root/src/generate_model/models'
generate_model_name = 'nisl_model'
else:
# model check
info_print('The new model is selected.')
generate_model_dir = hparams.finetuned_model_dir
generate_model_name = hparams.finetuned_model_name
if not os.path.exists(
os.path.join(
os.path.join(generate_model_dir, generate_model_name),
'checkpoint')):
raise FileNotFoundError(
"The specified model doesn't exist, please finetune first or set 'use_nisl_model=1'"
)
time.sleep(1)
info_print(
"Generating JS test program (approx 15 minutes with gpus when nsamples=512 - including model load time)...\n"
)
gpt2.load_gpt2(sess,
model_dir=generate_model_dir,
model_name=generate_model_name,
multi_gpu=hparams.multi_gpu)
assert hparams.batch_size != 0, "'batch_size' cannot be 0!"
batches = int(math.ceil(hparams.nsamples / hparams.batch_size))
remainder = hparams.nsamples % hparams.batch_size
all_functions = []
for idx in range(batches):
try:
texts = gpt2.generate(sess,
model_dir=generate_model_dir,
model_name=generate_model_name,
nsamples=hparams.batch_size,
batch_size=hparams.batch_size,
prefix=hparams.generate_prefix,
top_p=hparams.top_p,
top_k=hparams.top_k,
temperature=hparams.temperature,
include_prefix=True,
return_as_list=True)
# when the last batch, intercepted by the remainder
if idx == batches - 1:
if remainder != 0:
texts = texts[:remainder]
for text in texts:
functions = text.split(hparams.generate_prefix)[1:]
# get rid of the last one to prevent syntax errors
if len(functions) >= 2:
functions = functions[:-1]
all_functions += functions
# print
for function in functions:
print(function)
print('=' * 50)
info_print(f'Generating {idx+1}/{batches}.')
except:
continue
# formatting
all_functions = [i.strip() + '\n' for i in all_functions]
# save all generated functions by gpt2 to a new file
if not os.path.exists(saved_dir):
os.makedirs(saved_dir)
for idx, function in enumerate(all_functions, start=1):
with open(os.path.join(saved_dir, f'{idx}.js'), 'w',
encoding='utf-8') as f:
f.write(function)
return all_functions
def reset_generator(self):
self.app.logger.info('resetting %s session', self.genre)
self.sess = gpt2.reset_session(self.sess, threads=1)
gpt2.load_gpt2(self.sess, checkpoint_dir=self.checkpoint_dir)
question_sentiment = "like" #default sentiment is to ask if you like something
model_name = '124M'
run_name = "run_10"
sess2 = gpt2.start_tf_sess(threads=8)
global graph2
graph2 = tf.compat.v1.get_default_graph()
with graph2.as_default():
#tf.compat.v1.get_variable_scope().reuse_variables()
#with tf.compat.v1.variable_scope("m2"):
gpt2.load_gpt2(sess2, run_name="run_10_2", scope="m2")
sess = gpt2.start_tf_sess(threads=8)
sess = gpt2.reset_session(sess, threads=8)
global graph
graph = tf.compat.v1.get_default_graph()
with graph.as_default():
gpt2.load_gpt2(sess, run_name=run_name)
sess3 = gpt2.start_tf_sess(threads=8)
sess3 = gpt2.reset_session(sess3, threads=8)
global graph3
graph3 = tf.compat.v1.get_default_graph()
with graph3.as_default():
gpt2.load_gpt2(sess3, run_name="run_10_3", scope="m3")
def generate_trending_tweet():
# pick a topic
trending = get_trending()
topic = choice(trending)
print("generating tweets on topic: " + topic)
# fetch tweets on topic
file_name = "../data/" + topic + ".txt"
topical_tweets = get_topic_tweet(topic, 1000)
tweet_string = " || ".join(topical_tweets)
with open(file_name, "w") as f:
f.write(tweet_string)
# train a model on new tweets
sess = gpt2.start_tf_sess()
if not os.path.exists("checkpoint/" + topic):
gpt2.finetune(
sess,
dataset=file_name,
model_name=model_name,
steps=2,
restore_from="fresh",
run_name=topic,
print_every=1,
)
else:
gpt2.finetune(
sess,
dataset=file_name,
model_name=model_name,
steps=1,
restore_from="latest",
run_name=topic,
print_every=1,
)
# generate text with the new model
gpt2.generate_to_file(
sess,
length=400,
destination_path="../data/generated_tweets.txt",
nsamples=5,
run_name=topic,
prefix=topic,
)
gpt2.reset_session(sess)
# filter and return 1 valid tweet from the gerated text
with open("../data/generated_tweets.txt", "r") as f:
texts = f.read().split("====================")
tweets = []
for text in texts:
tweeters = text.split(" || ")
for tweet in tweeters:
if topic in tweet:
tweet = tweet.split(" ")
tweet = " ".join(word for word in tweet
if not filter_links(word))
if len(tweet) > len(topic) + 4:
tweets.append(tweet)
else:
continue
tweet = choice(tweets)
if len(tweet) > 280:
tweet = tweet[:280]
return tweet
