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 JSONResponse({'text': ''}, headers=response_header)
print('+++++++++++++++')
print(params)
text = gpt2.generate(sess,
length=100,
temperature=float(params.get('temperature', 0.7)),
prefix=params.get('prefix', '')[:500],
return_as_list=True)[0]
generate_count += 1
if generate_count == 8:
# Reload model to prevent Graph/Session from going OOM
tf.reset_default_graph()
sess.close()
sess = gpt2.start_tf_sess(threads=1)
gpt2.load_gpt2(sess)
generate_count = 0
gc.collect()
text = re.split('\n', text)
return JSONResponse({'text': text}, headers=response_header)
def on_status(self, tweet):
print("Received status.")
if self.is_mentioned(tweet):
username = tweet.user.screen_name
text = str(tweet.text)
# do I need to remove @sarcastic_trump before generating a new prediction?
text_without_self_username = text.replace("@sarcastic_trump", "")
try:
generated_tweet_from_text_as_prefix = self.generate_gpt2_tweet_using_prefix(
prefix=text_without_self_username)
except:
tf.reset_default_graph()
self.sess = gpt2.start_tf_sess()
gpt2.load_gpt2(self.sess, run_name='trump_clean_small')
generated_tweet_from_text_as_prefix = self.generate_gpt2_tweet_using_prefix(
prefix=text_without_self_username)
# remove the extra lines without punctuation. Might also remove hashtags # ?
tweet_without_extra_lines = self.remove_extra_lines(
generated_tweet_from_text_as_prefix[0])
print(f"{username}: {text}")
if len(generated_tweet_from_text_as_prefix[0]) + len(
username) + 5 > 240:
self.api.update_status(
f"Hey @{username}, {tweet_without_extra_lines[0:240-len(username)-5]}",
in_reply_to_status_id=tweet.id)
else:
self.api.update_status(
f"Hey @{username}, {tweet_without_extra_lines}",
in_reply_to_status_id=tweet.id)
def start():
print("Starting")
start_time = datetime.datetime.now()
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, model_name=model_name)
text = gpt2.generate(
sess,
model_name=model_name,
prefix=
"In a shocking finding, scientist discovered a herd of unicorns living in a remote, "
"previously unexplored valley, in the Andes Mountains. Even more surprising to the "
"researchers was the fact that the unicorns spoke perfect English.",
length=100,
temperature=0.7,
top_p=0.9,
return_as_list=True)
total_time = datetime.datetime.now() - start_time
print("Total time required is = ", total_time)
print(text)
return " ".join(text)
def main(args):
"""
Load generated model checkpoints from by default in /checkpoint/run1 and generate new text
"""
try:
config_path = project_path + "/" + args.config
input_data_path = project_path + "/" + args.input
output_data_path = project_path + "/" + args.output
config = load_config(config_path)
# load data
df = read_csv(input_data_path)
lines = list(df['raw_line'])
random.seed(config['generate']['random_seed'])
sample_seeds = random.choices(lines, k=config['generate']['num'])
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess)
pred = []
for i in sample_seeds:
out = gpt2.generate(sess,
prefix=i,
**config['generate']['generator'])
pred.append(out)
pred_df = pd.DataFrame(pred, columns=['raw_line'])
save_csv(pred_df, output_data_path)
except Exception as e:
logger.error(
"Unexpected error occurred when generating dialogues with gpt2: " +
str(e))
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)
'''
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 get(self, context=''):
run_name = 'run3'
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, run_name=run_name)
results = gpt2.generate(sess,
run_name=run_name,
prefix=context,
nsamples=10,
length=200,
batch_size=10,
temperature=1,
top_k=40,
include_prefix=True,
return_as_list=True)
all_tweets = []
for result in results:
subtweets = result.splitlines()
all_tweets = list(set(all_tweets + subtweets))
with io.open('tweets_unseparated.txt', 'r',
encoding="utf-8") as tweet_file:
original_tweets = tweet_file.readlines()
original_tweets = [x.strip() for x in original_tweets]
all_tweets = list(set(all_tweets) - set(original_tweets))
result = {'predicted_text': all_tweets}
return jsonify(result)
def generate(prefix, input_file, similarity_threshold, nsamples, length,
temperature, k):
# load the quotes used for fine-tuning
with open(input_file, 'r') as f:
originals = f.readlines()
original_quotes = [
originals[i].strip() for i in range(1, len(originals), 3)
]
# generate a batch of quotes
sess = gpt2s.start_tf_sess()
gpt2s.load_gpt2(sess)
samples = gpt2s.generate(sess,
nsamples=nsamples,
length=length,
temperature=temperature,
top_k=k,
prefix=prefix + '\n',
return_as_list=True)
# filter the samples
quotes = []
for s in samples:
title, body = s.split('\n')[:2]
is_long = len(body.split(' ')) > 3
is_novel = all(
similar(body, x) < similarity_threshold for x in original_quotes)
if is_long and is_novel:
quotes.append(body)
return quotes
def main():
helix = twitch.Helix('', use_cache=True)
global lastmsg, msg
lastmsg = datetime.datetime.now()
msg = queue.Queue(100)
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, run_name=run_name)
while not msg.full():
newmsg = genmsg(sess)
print(newmsg)
msg.put(newmsg)
for channel in textchannels:
chat = twitch.Chat(channel="#" + channel,
nickname='WoodenLongboard',
oauth="",
helix=helix)
chats[channel] = chat
chats[channel].subscribe(handle_message)
print("Finished init")
while True:
if not msg.full():
msg.put(genmsg(sess))
def generate():
first_line = request.args['firstLine']
first_line = '<|startoftext|> ' + first_line.lower()
sess = gpt2.start_tf_sess(threads=1)
gpt2.load_gpt2(sess, run_name="run1", checkpoint_dir="checkpoint")
output = ['']
while (len(output[0]) <= len(first_line) + 30):
output = gpt2.generate(sess,
run_name='run1',
checkpoint_dir='checkpoint',
model_dir='models',
sample_dir='samples',
return_as_list=True,
length=120,
temperature=0.7,
prefix=first_line,
truncate="<|endoftext|>",
include_prefix=True)
tf.reset_default_graph()
sess.close()
gc.collect()
data = output[0].replace('<|startoftext|> ', '')
return json.dumps({"data": data})
async def generate(input: str = "", auth: str = ""):
global sess, generate_count
if auth != AUTH_KEY:
return "Invalid auth token provided"
result = gpt2.generate(
sess,
run_name="run1",
length=300,
temperature=0.9,
prefix=input,
top_p=100,
nsamples=1,
batch_size=1,
include_prefix=False,
return_as_list=True,
)[0]
generate_count += 1
if generate_count == 12:
# Reload model to prevent Graph/Session from going OOM
tf.reset_default_graph()
sess.close()
sess = gpt2.start_tf_sess(threads=8)
gpt2.load_gpt2(sess, run_name="run1")
generate_count = 0
return result
async def _generate_samples(self, model: typing.Optional[str] = None, max_size=31):
if model == None:
return
cog_data_path = data_manager.cog_data_path(self)
model_path: pathlib.Path = cog_data_path / "models" / model
if not model_path.exists():
log.error(f"Model {model} not found in {str(cog_data_path)}")
return
tf_session = gpt_2_simple.start_tf_sess()
gpt_2_simple.load_gpt2(
tf_session,
checkpoint_dir=str(cog_data_path / "checkpoints"),
model_name=model,
model_dir=str(model_path.parent),
)
while True:
new_sample = gpt_2_simple.generate(
tf_session,
return_as_list=True,
truncate="<|endoftext|>",
temperature=1.0,
)[0]
async with self.full:
if len(self.samples) >= max_size:
log.info("Cache full, waiting for next command")
await self.full.wait()
self.samples.append(new_sample)
async with self.empty:
if len(self.samples) == 1:
self.empty.notify()
def generate_story():
global sess
# input text is request.form['input']
try:
tf.reset_default_graph()
sess.close()
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, run_name=request.form['genre'])
print("GENRE")
print(request.form['genre'])
generated_text = gpt2.generate(sess,
run_name=request.form['genre'],
length=200,
temperature=0.8,
prefix=str(request.form['input']),
nsamples=1,
batch_size=1,
return_as_list=True)[0]
return Response(response=generated_text, status=200)
except:
traceback.print_exc(file=sys.stdout)
print('aborting gen text')
abort(404)
def main():
if len(sys.argv) < 4:
print(
'Usage: python run_generator.py RUN_NAME SUBREDDIT NO_SAMPLES (TEMPERATURE)'
)
return
run_name = sys.argv[1]
subreddit = sys.argv[2]
try:
no_samples = int(sys.argv[3])
except Exception as e:
print(e)
print('Third argument should be an integer')
return
temperature = 1
if len(sys.argv) >= 5:
try:
temperature = float(sys.argv[4])
except Exception as e:
print(e)
print('Fourth argument should be a float')
return
update_checkpoint(run_name)
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, run_name=run_name, checkpoint_dir='generator_models')
generate_to_file(sess, run_name, subreddit, n=no_samples, temp=temperature)
print('Done.')
def generate_ideas():
prefix = request.args.get("prefix")
length = int(request.args.get("length", 50))
samples = int(request.args.get("samples", 1))
if samples <= 0 or samples > 5:
abort(
jsonify(
{
"message":
"Samples value is invalid, min 1 and max 5 allowed."
},
400,
))
session = gpt2.start_tf_sess()
gpt2.load_gpt2(session, model_name=model_name)
ideas = gpt2.generate(
session,
model_name=model_name,
prefix=prefix,
length=length,
nsamples=samples,
batch_size=samples,
)
session.close()
return jsonify(ideas=ideas)
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)
text = gpt2.generate(sess,
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]
generate_count += 1
if generate_count == 8:
# Reload model to prevent Graph/Session from going OOM
tf.reset_default_graph()
sess.close()
sess = gpt2.start_tf_sess(threads=1)
gpt2.load_gpt2(sess)
generate_count = 0
gc.collect()
return UJSONResponse({'text': text}, headers=response_header)
def loader(game_name):
print(Fore.GREEN)
l = pyfiglet.figlet_format("Loading...", font="slant")
print(Style.BRIGHT + l)
print(Fore.RESET)
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess)
input1 = "I am Leo"
stories = gpt2.generate(sess,
length=250,
temperature=0.7,
prefix=input1,
nsamples=5,
batch_size=5,
top_k=40,
return_as_list=True)
print(Fore.RESET + Style.RESET_ALL)
story = ""
temp = stories[3].split(".")
del temp[-1]
for i in temp:
story = story + i + '.'
return str(story)
def __init__(self, source, num_words, prompt="DEFAULT", temp=0.7):
#separating blocks into sentence tokens
nltk.download('punkt')
self.tokenizer = nltk.data.load('tokenizers/punkt/english.pickle')
#where the training data is stored
self.source = source
#deviation from original dataset
self.temperature = temp
#length of output
self.num_words = num_words
#user input
self.prompt = prompt
if self.prompt == "DEFAULT":
self.prompt = "The quick brown fox jumped over the lazy dog."
files = os.listdir(os.getcwd())
if "models" not in files:
#first-time runthrough
self.setupModel()
print('Setup Complete')
if "checkpoint" not in files:
#story generator, give parameters if necessary
self.trainGenerator()
print('Training Complete')
tf.reset_default_graph()
self.session = gpt2.start_tf_sess()
gpt2.load_gpt2(self.session, run_name='run1')
print('Done')
def main():
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess)
single_text = gpt2.generate(sess, return_as_list=True)[0]
print(single_text)
def _load_model(name):
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(
sess,
run_name=name,
checkpoint_dir=cfg.MODEL_DIR,
)
return sess
def loader():
# if 'sess' not in cache:
# cache['sess'] = gpt2.start_tf_sess()
# gpt2.load_gpt2(cache['sess'], checkpoint_dir='./gpt_2/checkpoint', run_name='run1')
# return cache['sess']
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, checkpoint_dir='../assets/gpt_2/checkpoint', run_name='run1')
return sess
def load_model(run):
# Get our pathfor the checkpoint setup
checkpoint_dir = Path("checkpoint").absolute()
# Start tensorflow session & load our model
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, checkpoint_dir=checkpoint_dir, run_name=run)
return sess
def __init__(self):
model_name = "774M"
run_name = 'run1'
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, model_name=model_name)
@bot.event
async def on_ready():
print('Logged in as')
print(bot.user.name)
print(bot.user.id)
print('------')
@bot.command()
async def hello(ctx):
"""-Tonto says hello!"""
await ctx.send("""Hello! I am Jaden Bot, a clone of my original host Jaden. I was designed to act as the Jaden replacment in the event people can not locate or access their local Jaden.""")
@bot.command()
async def story(ctx,*,input):
"""-Makes Jaden tell a story."""
eTxt = discord.Embed(name="LOADING", description="Loading Story ...")
await ctx.send(embed=eTxt)
result = gpt2.generate(
sess,
model_name=model_name,
top_k=40,
top_p = 0.9,
prefix=input,
truncate='<|endoftext|>',
length=100,
temperature=0.7,
nsamples=1,
batch_size=1,
return_as_list=True
)[0]
await ctx.send(result)
@bot.command()
async def say(ctx,*,input):
"""-Tonto will repeate what you write."""
await ctx.send(input)
@bot.command()
async def cmds(ctx):
"""-Will list commands if you can't use .help."""
with open('help.txt', 'r') as hfile:
data = hfile.read()
await ctx.send(data)
@bot.command()
async def repeat(ctx, times: int, content='repeating...'):
"""Repeats a message multiple times."""
for i in range(times):
await ctx.send(content)
bot.run(TOKEN)
def __init__(self, checkpoint_dir, run_name):
self.checkpoint_dir = checkpoint_dir
self.run_name = run_name
self.sess = gpt2.start_tf_sess()
gpt2.load_gpt2(self.sess,
run_name=self.run_name,
checkpoint_dir=self.checkpoint_dir,
model_name=None,
model_dir='models')
def start():
model_name = "124M"
if not os.path.isdir(os.path.join("models", model_name)):
print(f"Downloading {model_name} model...")
gpt2.download_gpt2(model_name=model_name)
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, model_name=model_name)
return sess
def generate_text():
gpt2.download_gpt2()
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess)
recipe = gpt2.generate(sess)
return render_template("index.html", recipe=recipe)
def setup(opts):
global run_name, sess
run_name = opts['run_name']
print(f'Run name: {run_name}')
shutil.copy(opts['checkpoint_file'],
f'checkpoints/{run_name}/model-10000.data-00000-of-00001')
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, run_name=run_name)
return None
def loadRun(self):
#load an existing trained run and generate from it
session = gpt2.start_tf_sess()
gpt2.load_gpt2(session, run_name='run1')
gpt2.generate_to_file(session,
include_prefix=False,
truncate=".",
destination_path='bot_says.txt',
length=self.num_words,
temperature=self.temperature,
prefix=self.prompt)
def gpt(sentence):
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, run_name='run1')
sent = gpt2.generate(sess,
run_name='run1',
return_as_list=True,
include_prefix=False,
prefix=sentence,
truncate='<|endoftext|>')
sess.close()
return sentence
def gen_story(mode, input_text, out_length=1023):
sess = gpt2.start_tf_sess()
check_dir = 'tf_model/355M_' + mode
gpt2.load_gpt2(sess, checkpoint_dir=check_dir)
text = gpt2.generate(sess, return_as_list=True,
checkpoint_dir=check_dir, prefix=input_text, length=out_length, include_prefix=True)
# tf.reset_default_graph()
# sess.close()
return text[0]
