Flaskapp

.flaskenv

@@ -0,0 +1,2 @@
+FLASK_APP=flaskapp
+FLASK_ENV=development

.gitignore

@@ -1,2 +1 @@
-__pycache__
-models/
+.env

flaskapp/.gitignore

@@ -0,0 +1 @@
+models/

flaskapp/__init__.py

@@ -0,0 +1,10 @@
+from flask import Flask
+from .routes import generator
+
+def create_app(config_file="settings.py"):
+    app = Flask(__name__, static_url_path="/tmp", static_folder="tmp")
+
+    app.config.from_pyfile(config_file)
+
+    app.register_blueprint(generator)
+    return app

src/encoder.py → flaskapp/encoder.py

@@ -106,9 +106,10 @@ def decode(self, tokens):
         return text
 
 def get_encoder(model_name):
-    with open(os.path.join('models', model_name, 'encoder.json'), 'r') as f:
+    currentPath = os.path.dirname(__file__) + "/models" + "/" + model_name
+    with open(currentPath + '/encoder.json', 'r') as f:
         encoder = json.load(f)
-    with open(os.path.join('models', model_name, 'vocab.bpe'), 'r', encoding="utf-8") as f:
+    with open(currentPath + '/vocab.bpe', 'r', encoding="utf-8") as f:
         bpe_data = f.read()
     bpe_merges = [tuple(merge_str.split()) for merge_str in bpe_data.split('\n')[1:-1]]
     return Encoder(

flaskapp/generator.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+
+import fire
+import json
+import os
+import numpy as np
+import tensorflow.compat.v1 as tf
+
+from flaskapp import model
+from flaskapp import sample
+from flaskapp import encoder
+
+class AI:
+    def generate_text(self, text_input, model_name="124M_alice", length=100):
+        seed=None
+        nsamples=1
+        batch_size=1
+        temperature=1
+        top_k=40
+        top_p=1
+
+        self.response = ""
+
+        currentPath = os.path.dirname(__file__) + "/models" + "/" + model_name
+
+        if batch_size is None:
+            batch_size = 1
+        assert nsamples % batch_size == 0
+
+        enc = encoder.get_encoder(model_name)
+        hparams = model.default_hparams()
+        with open(currentPath + '/hparams.json') as f:
+            hparams.override_from_dict(json.load(f))
+
+        if length is None:
+            length = hparams.n_ctx // 2
+        elif length > hparams.n_ctx:
+            raise ValueError("Can't get samples longer than window size: %s" % hparams.n_ctx)
+
+        with tf.Session(graph=tf.Graph()) as sess:
+            context = tf.placeholder(tf.int32, [batch_size, None])
+            np.random.seed(seed)
+            tf.set_random_seed(seed)
+            output = sample.sample_sequence(
+                hparams=hparams, length=length,
+                context=context,
+                batch_size=batch_size,
+                temperature=temperature, top_k=top_k, top_p=top_p
+            )
+
+            saver = tf.train.Saver()
+            ckpt = tf.train.latest_checkpoint(currentPath)
+            saver.restore(sess, ckpt)
+
+            context_tokens = enc.encode(text_input)
+            generated = 0
+            for _ in range(nsamples // batch_size):
+                out = sess.run(output, feed_dict={
+                    context: [context_tokens for _ in range(batch_size)]
+                })[:, len(context_tokens):]
+                for i in range(batch_size):
+                    generated += 1
+                    text = enc.decode(out[i])
+                    self.response = text
+        return self.response
+
+ai = AI()

src/model.py → flaskapp/model.py

@@ -1,6 +1,15 @@
 import numpy as np
-import tensorflow as tf
-from tensorflow.contrib.training import HParams
+import tensorflow.compat.v1 as tf
+
+class HParams(object):
+    def __init__(self, **kwargs):
+        for (k, v) in kwargs.items():
+            setattr(self, k, v)
+
+    def override_from_dict(self, kwargs):
+        for (k, v) in kwargs.items():
+            setattr(self, k, v)
+
 
 def default_hparams():
     return HParams(
@@ -28,7 +37,7 @@ def gelu(x):
 def norm(x, scope, *, axis=-1, epsilon=1e-5):
     """Normalize to mean = 0, std = 1, then do a diagonal affine transform."""
     with tf.variable_scope(scope):
-        n_state = x.shape[-1].value
+        n_state = shape_list(x)[-1]
         g = tf.get_variable('g', [n_state], initializer=tf.constant_initializer(1))
         b = tf.get_variable('b', [n_state], initializer=tf.constant_initializer(0))
         u = tf.reduce_mean(x, axis=axis, keepdims=True)
@@ -91,7 +100,7 @@ def mask_attn_weights(w):
     def multihead_attn(q, k, v):
         # q, k, v have shape [batch, heads, sequence, features]
         w = tf.matmul(q, k, transpose_b=True)
-        w = w * tf.rsqrt(tf.cast(v.shape[-1].value, w.dtype))
+        w = w * tf.rsqrt(tf.cast(shape_list(v)[-1], w.dtype))
 
         w = mask_attn_weights(w)
         w = softmax(w)
@@ -114,15 +123,15 @@ def multihead_attn(q, k, v):
 
 def mlp(x, scope, n_state, *, hparams):
     with tf.variable_scope(scope):
-        nx = x.shape[-1].value
+        nx = shape_list(x)[-1]
         h = gelu(conv1d(x, 'c_fc', n_state))
         h2 = conv1d(h, 'c_proj', nx)
         return h2
 
 
 def block(x, scope, *, past, hparams):
     with tf.variable_scope(scope):
-        nx = x.shape[-1].value
+        nx = shape_list(x)[-1]
         a, present = attn(norm(x, 'ln_1'), 'attn', nx, past=past, hparams=hparams)
         x = x + a
         m = mlp(norm(x, 'ln_2'), 'mlp', nx*4, hparams=hparams)
@@ -144,7 +153,7 @@ def positions_for(tokens, past_length):
     return expand_tile(past_length + tf.range(nsteps), batch_size)
 
 
-def model(hparams, X, past=None, scope='model', reuse=False):
+def model(hparams, X, past=None, scope='model', reuse=tf.AUTO_REUSE):
     with tf.variable_scope(scope, reuse=reuse):
         results = {}
         batch, sequence = shape_list(X)
@@ -162,6 +171,8 @@ def model(hparams, X, past=None, scope='model', reuse=False):
         assert len(pasts) == hparams.n_layer
         for layer, past in enumerate(pasts):
             h, present = block(h, 'h%d' % layer, past=past, hparams=hparams)
+            if layer == 10:
+                tf.add_to_collection('checkpoints', h)
             presents.append(present)
         results['present'] = tf.stack(presents, axis=1)
         h = norm(h, 'ln_f')

flaskapp/requirements.txt

@@ -0,0 +1,3 @@
+Python==3.8.10
+Flask==2.1.1
+Werkzeug==2.0.3

flaskapp/routes.py

@@ -0,0 +1,18 @@
+from inspect import Parameter
+from django.shortcuts import render
+from flask import Blueprint, render_template, request, redirect
+from .generator import ai
+
+generator = Blueprint('generator', __name__)
+
+@generator.route('/')
+def index():
+    # parameter = request.form['parameter']
+    return render_template('index.html')
+
+@generator.route('/analyze', methods=['POST'])
+def analyze():
+    title = request.form['title']
+    text = ai.generate_text(title)
+
+    return render_template('index.html', text=text)

flaskapp/sample.py

@@ -0,0 +1,93 @@
+import tensorflow.compat.v1 as tf
+
+from flaskapp import model
+
+def top_k_logits(logits, k):
+    if k == 0:
+        # no truncation
+        return logits
+
+    def _top_k():
+        values, _ = tf.nn.top_k(logits, k=k)
+        min_values = values[:, -1, tf.newaxis]
+        return tf.where(
+            logits < min_values,
+            tf.ones_like(logits, dtype=logits.dtype) * -1e10,
+            logits,
+        )
+    return tf.cond(
+       tf.equal(k, 0),
+       lambda: logits,
+       lambda: _top_k(),
+    )
+
+
+def top_p_logits(logits, p):
+    with tf.variable_scope('top_p_logits'):
+        logits_sort = tf.sort(logits, direction='DESCENDING')
+        probs_sort = tf.nn.softmax(logits_sort)
+        probs_sums = tf.cumsum(probs_sort, axis=1, exclusive=True)
+        logits_masked = tf.where(probs_sums < p, logits_sort, tf.ones_like(logits_sort)*1000) # [batchsize, vocab]
+        min_logits = tf.reduce_min(logits_masked, axis=1, keepdims=True) # [batchsize, 1]
+        return tf.where(
+            logits < min_logits,
+            tf.ones_like(logits, dtype=logits.dtype) * -1e10,
+            logits,
+        )
+
+
+def sample_sequence(*, hparams, length, start_token=None, batch_size=None, context=None, temperature=1, top_k=0, top_p=0.0):
+    if start_token is None:
+        assert context is not None, 'Specify exactly one of start_token and context!'
+    else:
+        assert context is None, 'Specify exactly one of start_token and context!'
+        context = tf.fill([batch_size, 1], start_token)
+
+    def step(hparams, tokens, past=None):
+        lm_output = model.model(hparams=hparams, X=tokens, past=past, reuse=tf.AUTO_REUSE)
+
+        logits = lm_output['logits'][:, :, :hparams.n_vocab]
+        presents = lm_output['present']
+        presents.set_shape(model.past_shape(hparams=hparams, batch_size=batch_size))
+        return {
+            'logits': logits,
+            'presents': presents,
+        }
+
+    with tf.name_scope('sample_sequence'):
+        def body(past, prev, output):
+            next_outputs = step(hparams, prev, past=past)
+            logits = next_outputs['logits'][:, -1, :]  / tf.to_float(temperature)
+            if top_p > 0.0:
+                logits = top_p_logits(logits, p=top_p)
+            else:
+                logits = top_k_logits(logits, k=top_k)
+            samples = tf.multinomial(logits, num_samples=1, output_dtype=tf.int32)
+            return [
+                next_outputs['presents'] if past is None else tf.concat([past, next_outputs['presents']], axis=-2),
+                samples,
+                tf.concat([output, samples], axis=1)
+            ]
+
+        past, prev, output = body(None, context, context)
+
+        def cond(*args):
+            return True
+
+        _, _, tokens = tf.while_loop(
+            cond=cond, body=body,
+            maximum_iterations=length - 1,
+            loop_vars=[
+                past,
+                prev,
+                output
+            ],
+            shape_invariants=[
+                tf.TensorShape(model.past_shape(hparams=hparams, batch_size=batch_size)),
+                tf.TensorShape([batch_size, None]),
+                tf.TensorShape([batch_size, None]),
+            ],
+            back_prop=False,
+        )
+
+        return tokens

flaskapp/settings.py

@@ -0,0 +1,4 @@
+import os
+
+ADMIN_USERNAME=os.environ.get('ADMIN_USERNAME')
+ADMIN_PASSWORD=os.environ.get('ADMIN_PASSWORD')

flaskapp/templates/index.html

@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+
+<html>
+    <head>
+        <style>
+
+        </style>
+    </head>
+    <body>
+        <div>
+            <form method="POST" action="{{ url_for('generator.analyze') }}">
+                <div>
+                    <label>Title</label>
+                    <input type="text" placeholder="Enter prompt" name="title"/>
+                </div>
+                <button type="submit">Submit</button>
+            </form>
+            <p>
+                {{ text }}
+            </p>
+        </div>
+    </body>
+</html>

gpt-2/.gitattributes

@@ -0,0 +1,6 @@
+# convert to OS line endings on checkout, back to LF on commit
+* text=auto
+
+# ensure anything copied to the container has unix style line endings
+*.sh text eol=lf
+requirements.txt text eol=lf