import gpt_2_simple as gpt2
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, checkpoint_dir="Plato/checkpoint")
answer = gpt2.generate(sess,
length=100,
include_prefix=False,
temperature=0.1,
top_k=1,
top_p=0.9,
model_dir="Plato/models",
sample_dir="Plato/samples",
checkpoint_dir="Plato/checkpoint",
run_name='run1',
prefix="What is philosophy",
return_as_list=True)
print(answer[0])
import gpt_2_simple as gpt2
# gpt2.download_gpt2(model_name="124M") # This could also be "124", `345M`, `774M`, or `1558M`
sess = gpt2.start_tf_sess()
gpt2.finetune(sess,
"words.txt",
model_name='124M',
steps=1,
restore_from='fresh',
run_name='run1')
gpt2.load_gpt2(sess)
gpt2.generate(sess, length=100, temperature=0.7, prefix="hi mom ", nsamples=1)
sess = gpt2.start_tf_sess()
gpt2.finetune(sess,
dataset=file_name,
model_name='124M',
steps=1000,
restore_from='fresh',
run_name='run1',
print_every=10,
sample_every=200,
save_every=500
)
gpt2.copy_checkpoint_to_gdrive(run_name='run1')
gpt2.copy_checkpoint_from_gdrive(run_name='run1')
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, run_name='run1')
gpt2.generate(sess, run_name='run1')
gpt2.generate(sess,
length=250,
temperature=0.7,
prefix="This restaurant is",
nsamples=5,
batch_size=5
)
#!./usr/bin/python3
import gpt_2_simple as gpt2
import warnings
warnings.filterwarnings("ignore", category=FutureWarning)
binary_input = "110100100011000110101010000111001111100110011000010110010011010101010000000100001100111000100100011010000000101011101000111011101001110100001100010001100100010001001111101101000010011010100110101010010101111000110001100011101010100100010010001111110000110110011110011010101000110011101010010010001001100000010100110110001010110001100000001011001101001111011001001110101110110001010011011011111110"
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess)
gpt2.generate(sess,
length=20,
temperature=.7,
prefix=binary_input,
nsamples=3
)
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)
category = params.get('category', '').lower().strip()
if category == '':
category = 'love'
if category not in VALID_CATEGORIES:
return UJSONResponse(
{'text': '<span style="font-size: 2em">ಠ_ಠ</span>'},
headers=response_header)
keywords = " ".join([
v.replace(' ', '-').strip() for k, v in params.items()
if 'key' in k and v != ''
])
prepend = "<|startoftext|>~`{}~^{}~".format(category, keywords) + "}"
text = prepend + params.get('prefix', '')[:100]
length = MIN_LENGTH
while '<|endoftext|>' not in text and length <= MAX_LENGTH:
text = gpt2.generate(sess,
length=STEP_LENGTH,
temperature=0.7,
top_k=40,
prefix=text,
include_prefix=True,
return_as_list=True)[0]
length += STEP_LENGTH
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
prepend_esc = re.escape(prepend)
eot_esc = re.escape('<|endoftext|>')
if '<|endoftext|>' not in text:
pattern = '(?:{})(.*)'.format(prepend_esc)
else:
pattern = '(?:{})(.*)(?:{})'.format(prepend_esc, eot_esc)
trunc_text = re.search(pattern, text)
return UJSONResponse({'text': trunc_text.group(1)},
headers=response_header)
"""After the model is trained, you can copy the checkpoint folder to your own Google Drive.
If you want to download it to your personal computer, it's strongly recommended you copy it there first, then download from Google Drive. The checkpoint folder is copied as a `.rar` compressed file; you can download it and uncompress it locally.
"""
gpt2.copy_checkpoint_to_gdrive(run_name='run1')
gpt2.load_gpt2(sess, run_name='run1')
"""## Generate Text From The Trained Model
After you've trained the model or loaded a retrained model from checkpoint, you can now generate text. `generate` generates a single text from the loaded model.
"""
gpt2.generate(sess, run_name='run1')
"""For bulk generation, you can generate a large amount of text to a file and sort out the samples locally on your computer. The next cell will generate a generated text file with a unique timestamp.
You can rerun the cells as many times as you want for even more generated texts!
"""
gen_file = 'gpt2_gentext_{:%Y%m%d_%H%M%S}.txt'.format(datetime.utcnow())
gpt2.generate_to_file(sess,
destination_path=gen_file,
length=500,
temperature=0.7,
nsamples=100,
batch_size=20
# Define a new pandas DataFrame to save songID , songName , Lyrics in it to use them later
lyrics_data = pd.DataFrame({'songID':songID, 'songName':songName, 'lyrics':lyrics })
lyrics_data.head(3)
with open('/content/drive/My Drive/lyrics.txt', 'w') as f:
for item in lyrics_data.lyrics.to_list():
f.write("%s\n" % item)
gpt2.copy_file_from_gdrive('lyrics.txt')
sess = gpt2.start_tf_sess()
gpt2.finetune(sess,
dataset='lyrics.txt',
model_name='124M',
steps=1000,
restore_from='fresh',
run_name='run1',
print_every=10,
sample_every=200,
save_every=500
)
gpt2.generate(sess,
length=250,
temperature=0.7,
prefix="My Love",
nsamples=5,
batch_size=5
)
overwrite=False,
steps=steps,
batch_size=2,
run_name=run_name) # steps is max number of training steps
gen_path = 'gen/' + run_name + '/result_' + str(i) + '.txt'
f = open(gen_path, "a+", encoding='utf8')
for j in range(iters):
prefix = ' '.join(prefix.split()[-35:])
print(prefix)
prefix = gpt2.generate(sess,
temperature=1.15,
top_k=30,
sample_delim=' ',
run_name=run_name,
prefix=prefix,
include_prefix=True,
truncate='<|endoftext|>',
return_as_list=True)[0]
prefix = re.sub(r' {2,}', ' ', prefix)
prefix = re.sub(r'\t{2,}', '\t', prefix)
prefix = re.sub(r'\n{2,}', '\n', prefix)
f.write(' '.join(prefix.split()[35:]))
f.close()
train_path = gen_path
steps = 10
sess.close()
def main():
"""
The main function.
"""
parser = argparse.ArgumentParser(
description="Finetune a GPT-2 model using ff2zim")
parser.add_argument("-d",
"--debug",
action="store_true",
help="show debug information")
subparsers = parser.add_subparsers(dest="action",
help="action to perform",
required=True)
# parser for generating trainingfile
tfparser = subparsers.add_parser(
"generate-trainingfile",
help="generate the trainingfile from a ff2zim project")
tfparser.add_argument("project", help="path to ff2zim project")
tfparser.add_argument("trainingfile", help="path to write trainingfile to")
tfparser.add_argument(
"--add-epub",
action="store",
nargs="*",
help="add an epub or a directory of epubs to the trainingfile",
metavar="PATH",
dest="epubpaths")
# parser for encoding the trainingfile
eparser = subparsers.add_parser(
"encode-trainingfile",
help="encode a trainingfile for better performance")
eparser.add_argument("trainingfile", help="path to trainingfile to encode")
eparser.add_argument("outfile", help="path to write to")
eparser.add_argument("model", help="model to encode for")
# parser for finetuning
finetuneparser = subparsers.add_parser(
"finetune", help="finetune a gpt-2 model using a trainingfile")
finetuneparser.add_argument("trainingfile", help="path to trainingfile")
finetuneparser.add_argument("--model",
action="store",
default="124M",
help="model to use")
finetuneparser.add_argument("--run-name",
action="store",
dest="runname",
default="run1",
help="run name for finetuned model.")
# parser for generating
genparser = subparsers.add_parser(
"generate", help="generate a sample with an interactive prompt")
genparser.add_argument("--model",
action="store",
default="124M",
help="model to use")
genparser.add_argument("--run-name",
action="store",
dest="runname",
default="run1",
help="run name for finetuned model.")
genparser.add_argument("-n",
"--numsamples",
action="store",
type=int,
help="number of samples to generate",
default=1)
genparser.add_argument("-m",
"--mode",
action="store",
choices=("story", "chapter", "complete"),
default="story")
ns = parser.parse_args()
if ns.action == "generate-trainingfile":
print("Generating trainingfile...")
trainingfile = ns.trainingfile
finetuner = GPT2Finetuner(ns.project, ns.epubpaths)
num_stories, num_epubs = finetuner.create_training_file(trainingfile)
print("Trainingfile successfully created.")
print("Included: {} fanfics and {} epubs.".format(
num_stories, num_epubs))
return
elif ns.action == "encode-trainingfile":
print("Encoding trainingfile...")
gpt2.encode_dataset(ns.trainingfile,
out_path=ns.outfile,
model_name=ns.model)
print("Done.")
return
elif ns.action == "finetune":
model = ns.model
if not os.path.isdir(os.path.join("models", model)):
print("Downloading the '{}' model...".format(model))
gpt2.download_gpt2(model_name=model)
print("Download finished.")
print("Starting TF session...")
sess = gpt2.start_tf_sess()
print("TF session started.")
print("Finetuning...")
gpt2.finetune(
sess,
ns.trainingfile,
model_name=model,
run_name=ns.runname,
print_every=100,
sample_every=500,
save_every=500,
use_memory_saving_gradients=True,
accumulate_gradients=1,
)
elif ns.action == "generate":
prepend_story_start = False
print("========== Generate a story ==========")
if ns.mode in ("story", "chapter"):
story_start = "\n" + TOKEN_STORY_START + "\n"
description_s = "\n" + TOKEN_DESCRIPTION_START + "\n"
description = input("Description of story: ")
description_s += description + "\n" + TOKEN_DESCRIPTION_END + "\n"
story_start += description_s + "\n" + TOKEN_CHAPTER_START + "\n"
prepend_story_start = True
elif ns.mode == "complete":
story_start = input("Prompt: ")
print("========== Generating... =========")
print("Starting TF session...")
sess = gpt2.start_tf_sess()
print("TF session started.")
print("Loading gpt-2...")
gpt2.load_gpt2(sess)
print("Loaded.")
print("Generating: ", end="", flush=True)
results = []
for i in range(ns.numsamples):
finished = False
storyparts = []
while not finished:
if not storyparts:
# first generation
prefix = story_start
elif prepend_story_start:
# also include story start
prefix = description_s
prefix += " ".join(storyparts[-1].split(" ")[-21:-1])
else:
prefix = " ".join(storyparts[-1].split(" ")[-21:-1])
multisamples = True
gpt2results = gpt2.generate(
sess,
model_name=ns.model,
run_name=ns.runname,
prefix=prefix,
return_as_list=True,
# nsamples=ns.numsamples,
seed=int(time.time()),
temperature=0.8,
top_k=50,
top_p=0.9,
nsamples=(5 if multisamples else 1),
)
result = None
for gpt2result in gpt2results:
gpt2result = gpt2result[len(prefix):]
if not is_looping(gpt2result):
result = gpt2result
break
if result is None:
# set default just to be sure
result = gpt2result
if ns.debug:
print("=====")
print("#storyparts: ", len(storyparts))
if len(storyparts) > 0:
print("-----\nLast storypart: \n-----\n",
storyparts[-1])
print("-----\nResult: \n-----\n", result)
print("=====")
if ns.mode == "story" or ns.mode == "chapter":
if is_looping(result):
print("L", end="", flush=True)
# remove last part to reduce chance of looping
storyparts = storyparts[:-1]
continue
# append result
storyparts.append(result)
if TOKEN_CHAPTER_END in result:
print("C", end="", flush=True)
if ns.mode == "chapter":
finished = True
elif TOKEN_STORY_END in result:
print("S", end="", flush=True)
finished = True
else:
print(".", end="", flush=True)
elif ns.mode == "complete":
# set result
storyparts = [prefix + result]
finished = True
# results.append(story[len(prefix):])
results.append("".join(storyparts))
print("\n", flush=True)
for text in results:
print("========= Result =========")
print(text)
temp = t / 10
for i in range(10):
monl = []
with open('names.txt', 'r') as f:
line = f.readline()
while line:
monl.append(
f'<|startoftext|>\n{{\n "monster_name": "{line.strip()}"'
)
line = f.readline()
print(monl)
monsters = gpt2.generate(sess,
return_as_list=True,
run_name="dnd11",
batch_prefix=monl,
temperature=temp,
batch_size=len(monl),
nsamples=len(monl),
truncate="<|endoftext|>",
length=10240)
for mon in monsters:
mon = mon.replace("<|startoftext|>\n", "")
print(mon)
quit()
try:
h = str(load(mon))
except:
pre_fix_exceptions += 1
mon = fix_json(mon, 100)
try:
h = str(load(mon))
print(run_name)
print("Model " + str(i + 1) + " from " + str(model_num))
print("=====================================")
sess = gpt2.reset_session(sess)
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, run_name=run_name)
generated_paraphrase[run_name] = {}
for test_input in test_input_list:
test_input = test_input.replace('\n', '')
gen_para = gpt2.generate(
sess,
run_name=run_name,
length=50,
temperature=1,
prefix=test_input,
nsamples=num_samples,
batch_size=1, #,
include_prefix=True,
truncate='<|end of text|>',
return_as_list=True)
#results will include the prefix since if include_prefix == False, the result sometimes not consistent, so more difficult to preprocess
generated_paraphrase[run_name][test_input] = {}
for i, x in enumerate(gen_para):
generated_paraphrase[run_name][test_input][i] = x.replace(
test_input, '').replace('/n', '')
dump_pickle("generated_paraphrase/" + output_file + '.pkl',
generated_paraphrase)
pd.concat(
url = 'https://drive.google.com/u/0/uc?id=1T5BntQPxoRjGDMAUbqUwUnsDs2DARM6C&export=download' #You can set your to your own model on gdrive
#ok but this is run2.tar
#not shakespeare.txt, so how to train your own
#good question https://github.com/minimaxir/gpt-2-simple or https://colab.research.google.com/drive/1VLG8e7YSEwypxU-noRNhsv5dW4NfTGce
output = 'run2.tar'
print("Downloading pretrained model...")
gdown.download(url, output, quiet=False)
print("Untar run2.tar")
exit(0)
runName = "run2"
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, run_name=runName)
print(
gpt2.generate(sess,
length=250,
temperature=0.7,
prefix="Fuhrer",
nsamples=5,
batch_size=5,
run_name=runName))
def generate(prefixs="nexity"):
return gpt2.generate(sess,
length=250,
temperature=0.7,
prefix=prefixs,
nsamples=5,
batch_size=5,
run_name=runName)
#!/usr/bin/env python3
import gpt_2_simple as gpt2
import json
pregenerated = open('pregenerated.json', 'r')
entries = json.load(pregenerated)
pregenerated.close()
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess)
petitions = gpt2.generate(sess,
prefix="<|startofpetition|>",
truncate="<|endofpetition|>",
include_prefix=False,
return_as_list=True,
batch_size=10,
nsamples=10)
for petition in petitions:
petition = petition.replace("<|startofpetition|>",
"") # Sometimes this gets duplicated
petition = petition.replace("Reason for rejection:",
"<h2>Why was this petition rejected?</h2>")
lines = petition.split("\n")
if lines[0].strip() == "":
start = 1
else:
start = 0
entry = {'title': lines[start], 'body': "<br />".join(lines[start + 2:])}
entries.append(entry)
gpt2GeneratedText = []
gpt2_length = []
file = open("BLM_CNN_GPT2_ouputs.txt",
"w") # Stores the output of each GPT2 generated article
for i in range(0, len(headlines), 1):
print("----------- " + str(i) + " -----------")
headline_prefix = headlines[i]
# Set the length of the generation to the max generation length if the article length is greater than the max
articleLength = len(article_text[i].split())
if articleLength > 1023:
articleLength = 1023
output = gpt2.generate(sess,
prefix=headline_prefix,
length=articleLength,
temperature=0.7,
top_p=0.9,
return_as_list=True)
print(output)
gpt2GeneratedText.append(output[0])
gpt2_length.append(articleLength)
file.write("---------------------------- " + str(i) +
" ----------------------------\n")
file.write("Prefix Text (Headlines): " + headline_prefix + "\n")
file.write("length: " + str(articleLength) + "\n")
file.write("GPT2 Output:\n" + output[0] + "\n\n")
file.close()
# Dictionary to storte the collected data in a .csv file
for idx, word in enumerate(split_tweet):
if idx < word_count:
tweet_prompt = tweet_prompt + word + " "
tweet_prompt = tweet_prompt.strip(" ")
# Generate the tweet using the gpt-2 model
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, run_name=model)
tweet = gpt2.generate(sess,
run_name=model,
checkpoint_dir=file_directory +
"/checkpoint",
length=100,
temperature=.7,
nsamples=1,
batch_size=1,
prefix=tweet_prompt,
truncate='<|endoftext|>',
include_prefix=True,
return_as_list=True)[0]
gpt2.reset_session(sess)
# Clean the tweet string
tweet = tweet.replace("\"]", "")
tweet = tweet.replace("[\"", "")
tweet = tweet.replace("\']", "")
tweet = tweet.replace("[\'", "")
tweet = tweet.replace("\\n", "\n")
tweet = tweet.replace("\\'", "\'")
########################
###### AthenaAI ######
###### 2021 ######
########################
import gpt_2_simple as gpt2
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess)
question_to_ask = "" # Put question here (as short as possible) and test the result.
answer = gpt2.generate(sess,
length=100,
include_prefix=True,
temperature=0.1,
top_k=1,
top_p=0.9,
run_name='run1',
prefix=question_to_ask,
return_as_list=True)[0]
print(answer)
import gpt_2_simple as gpt2
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess)
# pre = '<|newsubmission|>\n\nCMV: The internet is a "monopoly" where the price of knowledge is controlled by only a few, and the popularity of existing platforms and services is driven by a desire to sell more.\nI think that a lot of the criticism of the internet as a marketplace and a place where everyone is competing for resources is a bit unfair.\n<|newcomment|>'
pre = """
CMV: Seeing a person dressed as a woman that is clearly a man will never not be weird.
I know gender dysphoria is real and transgender people exist. I know that the world would be better off accepting that fact.
But in the push to accept transgender people in society, there seems to be this awkward game of pretend that is expected to be played.
It is one thing to simply adjust the pronouns you use to make them comfortable, but it is another thing entirely to be expected to convince yourself that they are the gender in which they identify. If you meet a trans woman that is clearly trans (most notably ones that used to be men with clear male facial features, endomorph or even receding hairlines) you are expected to actually believe she is a woman on a biological level.
There are some very lucky biological men that can transition and be incredibly convincing, but most aren't, and if you aren't one of those lucky people, you will never be seen as an actual woman no matter how much pretend we are expected to play. We can all act like they are women, but the brain already sorts them out as "men dressed as women" way before any conscious decision is made, and it will always be weird and awkward seeing these individuals no matter how nice and accepting we are about it.
<|newcomment|>
"""
single_text = gpt2.generate(sess,
prefix=pre,
truncate="<|newsubmission|>",
return_as_list=True)[0]
print("<|newsubmission|>\n")
print(single_text)
print_every=2,
sample_every=5,
save_every=10
)
#Stop to see if it's trained enough
gpt2.copy_checkpoint_to_gdrive(run_name='fantasy3')
input_text="I was riding a cycle when"
#this is where we enter the text to get suggestions
#Other hyperparameters
length=20
top_p=0.5
temperature=0.9
top_k=0.8
#To be used while running
gpt2.generate(sess,
prefix=input_text,
length=length,
temperature=temperature,
top_p=top_p,
top_k=top_k,
nsamples=5,
batch_size=5,
include_prefix=False,
return_as_list=True
)
# Loads suggestions
gpt2.copy_checkpoint_to_gdrive()
first = True
cycleCount = 0
while True:
debug.append('\n\ncycle %i' % cycleCount)
debug.append('prefix:')
debug.append(prefix)
cycleCount += 1
if startFile and first:
text = readFile(startFile)
else:
text = gpt2.generate(sess,
run_name=run_name,
prefix=prefix,
temperature=(temp / 100),
return_as_list=True)[0]
first = False
debug.append('output:')
debug.append(text)
print('\n\noutput:')
print(text)
newLines = text.split('\n')
direction = None
lastIndex = None
for line in newLines:
def create_recipe():
text = gpt2.generate(sess, return_as_list=True, length=200)[0]
text = "\n".join(text.split("."))
print(text)
#!/usr/bin/env python
import gpt_2_simple as gpt2
import sys
if len(sys.argv) > 1:
prompt = sys.argv[1]
else:
prompt = "prompt: So, what's new around here?"
print(prompt)
sys.exit(1)
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess)
single_text = gpt2.generate(
sess,
return_as_list=True,
temperature=0.75,
include_prefix=False,
truncate="<|endoftext|>",
prefix="""ASCII Today - Fun with the Teletype Terminal"""
)[0]
print(single_text)
import gpt_2_simple as gpt2
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess)
single_text = gpt2.generate(sess,
length=60,
temperature=0.7,
prefix="Meu amor",
nsamples=5,
batch_size=5,
return_as_list=True)[0]
# print(single_text)
model_name=model_name,
steps=int(rounds),
run_name="run" + model_name)
y = False
elif response == 'n':
gpt2.reset_session(sess)
gpt2.finetune(sess,
fil,
model_name=model_name,
steps=int(rounds),
run_name="run" + model_name)
y = False
else:
print('(y/n) please')
print("Generating text... this might take a while:")
gpt2.generate(sess, truncate='<|endoftext|>')
elif response == 'n':
print(
'Alright I can only generate then, using the older model saved in checkpoint.'
)
x = False
print("Generating text... this might take a while:")
gpt2.generate(sess, truncate='<|endoftext|>')
else:
print('(y/n) please')
elif response == 'n':
print('Got it, Generating only then')
if not sess_flag:
# gpt2.load_gpt2(sess)
gpt2.load_gpt2(sess, run_name="run" + model_name)
import gpt_2_simple as gpt2s
import os
import requests
import better_profanity
FILE_PATH = ""
meme_model = "124M"
gpt2s.download_gpt2(model_name=meme_model)
with open(FILE_PATH + "extracted_text.txt") as extracted_text:
extracted_text = better_profanity.censor(extracted_text)
session = gpt2s.start_tf_sess()
gpt2s.finetune(session, extracted_text, meme_model, steps=100)
txt_list = gpt2s.generate(session, temperature=0.7, return_as_list=True)
print(txt_list)
def gen_fresh():
content = request.json
min_length = content['min_sample_len']
max_length = content['max_sample_len']
num_samples = 1
past_context_len = content['past_context_len']
iterations = content['iterations']
model_str = content['writer']
model_name = model_map[model_str]
generated_str = ""
random_len = random.randint(min_length, max_length)
# setup gpt2
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess, model_name=model_name)
output = gpt2.generate(
sess,
checkpoint_dir="models",
run_name=model_name,
length=random_len,
prefix="<|startoftext|>",
temperature=0.9,
top_k=50,
top_p=0.95,
# nsamples=num_samples,
# batch_size=num_samples,
return_as_list=True)
output_str = output[0]
output_str_arr = output_str.split(' ')
input_str = ' '.join(output_str_arr[-past_context_len:])
if iterations != 0:
generated_str += ' '.join(
output_str_arr[:-past_context_len]) + ' ' # or '\n'
else:
generated_str += output_str + ' '
for i in range(iterations - 1):
random_len = random.randint(min_length, max_length)
output = gpt2.generate(
sess,
checkpoint_dir="models",
run_name=model_name,
length=random_len,
prefix=input_str,
temperature=0.9,
top_k=50,
top_p=0.95,
# nsamples=num_samples,
# batch_size=num_samples,
return_as_list=True)
output_str = output[0]
output_str_arr = output_str.split(' ')
input_str = ' '.join(output_str_arr[-past_context_len:])
# add the entire str if not last iteration, otherwise omit the starting input
if iterations != iterations - 2:
generated_str += ' '.join(
output_str_arr[:-past_context_len]) + ' ' # or '\n'
else:
generated_str += output_str + ' '
tf.reset_default_graph()
sess.close()
res = {'output': generated_str}
return jsonify(res)
def train(filename):
sess = gpt2.start_tf_sess()
gpt2.finetune(sess, filename, model_name=model_name,
steps=1000) # steps is max number of training steps
gpt2.generate(sess)
import gpt_2_simple as gpt2
import os
import requests
model_name = "124M"
if not os.path.isdir(os.path.join("models", model_name)):
print("Downloading {model_name} model...")
gpt2.download_gpt2(
model_name=model_name
) # model is saved into current directory under /models/124M/
file_name = "sourcetext/grimms_fairy_tales.txt"
if not os.path.isfile(file_name):
url = "http://www.gutenberg.org/files/2591/2591-0.txt"
data = requests.get(url)
with open(file_name, 'w') as f:
f.write(data.text)
sess = gpt2.start_tf_sess()
gpt2.finetune(sess, file_name, model_name=model_name,
steps=1000) # steps is max number of training steps
gpt2.generate(sess)
gpt2.finetune(sess,
dataset=file_name,
model_name='124M',
steps=1000,
restore_from='fresh',
run_name='run1',
print_every=10,
sample_every=200,
save_every=500
)
#generation
gpt2.generate(sess,
length=150,
temperature=0.7,
prefix="Two households, both alike in dignity",
nsamples=5,
batch_size=5
)
gpt2.generate(sess,
length=150,
temperature=0.7,
prefix="Who's there?",
nsamples=5,
batch_size=5
)
gpt2.generate(sess,
length=150,
temperature=0.7,
length=length,
temperature=0.4,
nsamples=1,
return_as_list=True,
include_prefix=include_prefix,
)[0]
os.chdir(old_wd)
return generated
if __name__ == "__main__":
prefixes = [
"He's gonna go for the flip-reset",
"And we're in the grand finals",
"David passes to Robbie",
"And we're at match point",
]
for prefix in prefixes:
# Generates the messages using the model.
generated = gpt2.generate(
sess,
prefix=prefix,
length=25,
temperature=0.2,
nsamples=5,
return_as_list=True,
)
print("\n".join(generated))
print()
# saving the text generated when run at 200 steps
import gpt_2_simple as gpt2
import json
sess = gpt2.start_tf_sess()
gpt2.load_gpt2(sess)
# gpt2.generate(sess)
text = gpt2.generate(sess, return_as_list=True, batch_size=5, nsamples=5)
with open("GPT2_Surrealist_Text_200new.json", "w") as output:
json.dump(text, output, indent=2)
