Spaces:

openai
/

openai-detector

Running on CPU Upgrade

App Files Files Community

XciD HF staff commited on Jan 5, 2023

Commit

30c8aac

•

1 Parent(s): 41ec8fd

add diff

Browse files

Files changed (4) hide show

detector-base.pt +3 -0
detector/index.html +15 -2
detector/server.py +36 -6
detector/server_get.py +120 -0

detector-base.pt ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:c74935bd6568940038e6bfcc9c90bf821d7ae4163ebf2327b73db2f641376376
+size 501001061

detector/index.html CHANGED Viewed

@@ -2,6 +2,7 @@
 <html>
 <head>
 <title>GPT-2 Output Detector</title>
 <style type="text/css">
 * {
     box-sizing: border-box;
@@ -74,7 +75,9 @@ em {
     <p>
         This is an online demo of the
         <a href="https://github.com/openai/gpt-2-output-dataset/tree/master/detector">GPT-2 output detector</a>
-        model. Enter some text in the text box; the predicted probabilities will be displayed below.
         <u>The results start to get reliable after around 50 tokens.</u>
     </p>
     <textarea id="textbox" placeholder="Enter text here"></textarea>
@@ -134,7 +137,7 @@ textbox.oninput = () => {
             update_graph(null);
             return;
         }
-        req.open('GET', '/?' + textbox.value, true);
         req.onreadystatechange = () => {
             if (req.readyState !== 4) return;
             if (req.status !== 200) throw new Error("HTTP status: " + req.status);
@@ -150,5 +153,15 @@ window.addEventListener('DOMContentLoaded', () => {
     textbox.focus();
 });
 </script>
 </body>
 </html>

 <html>
 <head>
 <title>GPT-2 Output Detector</title>
+<meta charset="utf-8">
 <style type="text/css">
 * {
     box-sizing: border-box;
     <p>
         This is an online demo of the
         <a href="https://github.com/openai/gpt-2-output-dataset/tree/master/detector">GPT-2 output detector</a>
+        model, based on the <a href="https://github.com/huggingface/transformers/commit/1c542df7e554a2014051dd09becf60f157fed524"><code>🤗/Transformers</code></a>
+        implementation of <a href="https://arxiv.org/abs/1907.11692">RoBERTa</a>.
+        Enter some text in the text box; the predicted probabilities will be displayed below.
         <u>The results start to get reliable after around 50 tokens.</u>
     </p>
     <textarea id="textbox" placeholder="Enter text here"></textarea>
             update_graph(null);
             return;
         }
+        req.open('GET', window.location.href + '?' + textbox.value, true);
         req.onreadystatechange = () => {
             if (req.readyState !== 4) return;
             if (req.status !== 200) throw new Error("HTTP status: " + req.status);
     textbox.focus();
 });
 </script>
+<script>
+if (! ['localhost', 'huggingface.test'].includes(window.location.hostname)) {
+    (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+    (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+    m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+    })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
+    ga('create', 'UA-83738774-5', 'auto');
+    ga('send', 'pageview');
+}
+</script>
 </body>
 </html>

detector/server.py CHANGED Viewed

@@ -20,6 +20,30 @@ def log(*args):
 class RequestHandler(SimpleHTTPRequestHandler):
     def do_GET(self):
         query = unquote(urlparse(self.path).query)
@@ -32,6 +56,16 @@ class RequestHandler(SimpleHTTPRequestHandler):
         self.begin_content('application/json;charset=UTF-8')
         tokens = tokenizer.encode(query)
         all_tokens = len(tokens)
         tokens = tokens[:tokenizer.max_len - 2]
@@ -45,12 +79,7 @@ class RequestHandler(SimpleHTTPRequestHandler):
         fake, real = probs.detach().cpu().flatten().numpy().tolist()
-        self.wfile.write(json.dumps(dict(
-            all_tokens=all_tokens,
-            used_tokens=used_tokens,
-            real_probability=real,
-            fake_probability=fake
-        )).encode())
     def begin_content(self, content_type):
         self.send_response(200)
@@ -118,3 +147,4 @@ def main(checkpoint, port=8080, device='cuda' if torch.cuda.is_available() else
 if __name__ == '__main__':
     fire.Fire(main)

 class RequestHandler(SimpleHTTPRequestHandler):
+    def do_POST(self):
+        self.begin_content('application/json,charset=UTF-8')
+        content_length = int(self.headers['Content-Length'])
+        if content_length > 0:
+            post_data = self.rfile.read(content_length).decode('utf-8')
+            try:
+                post_data = json.loads(post_data)
+                if 'text' not in post_data:
+                    self.wfile.write(json.dumps({"error": "missing key 'text'"}).encode('utf-8'))
+                else:
+                    all_tokens, used_tokens, fake, real = self.infer(post_data['text'])
+                    self.wfile.write(json.dumps(dict(
+                        all_tokens=all_tokens,
+                        used_tokens=used_tokens,
+                        real_probability=real,
+                        fake_probability=fake
+                    )).encode('utf-8'))
+            except Exception as e:
+                self.wfile.write(json.dumps({"error": str(e)}).encode('utf-8'))
     def do_GET(self):
         query = unquote(urlparse(self.path).query)
         self.begin_content('application/json;charset=UTF-8')
+        all_tokens, used_tokens, fake, real = self.infer(query)
+        self.wfile.write(json.dumps(dict(
+            all_tokens=all_tokens,
+            used_tokens=used_tokens,
+            real_probability=real,
+            fake_probability=fake
+        )).encode())
+    def infer(self, query):
         tokens = tokenizer.encode(query)
         all_tokens = len(tokens)
         tokens = tokens[:tokenizer.max_len - 2]
         fake, real = probs.detach().cpu().flatten().numpy().tolist()
+        return all_tokens, used_tokens, fake, real
     def begin_content(self, content_type):
         self.send_response(200)
 if __name__ == '__main__':
     fire.Fire(main)

detector/server_get.py ADDED Viewed

	@@ -0,0 +1,120 @@

+import os
+import sys
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from multiprocessing import Process
+import subprocess
+from transformers import RobertaForSequenceClassification, RobertaTokenizer
+import json
+import fire
+import torch
+from urllib.parse import urlparse, unquote
+model: RobertaForSequenceClassification = None
+tokenizer: RobertaTokenizer = None
+device: str = None
+def log(*args):
+    print(f"[{os.environ.get('RANK', '')}]", *args, file=sys.stderr)
+class RequestHandler(SimpleHTTPRequestHandler):
+    def do_GET(self):
+        query = unquote(urlparse(self.path).query)
+        if not query:
+            self.begin_content('text/html')
+            html = os.path.join(os.path.dirname(__file__), 'index.html')
+            self.wfile.write(open(html).read().encode())
+            return
+        self.begin_content('application/json;charset=UTF-8')
+        tokens = tokenizer.encode(query)
+        all_tokens = len(tokens)
+        tokens = tokens[:tokenizer.max_len - 2]
+        used_tokens = len(tokens)
+        tokens = torch.tensor([tokenizer.bos_token_id] + tokens + [tokenizer.eos_token_id]).unsqueeze(0)
+        mask = torch.ones_like(tokens)
+        with torch.no_grad():
+            logits = model(tokens.to(device), attention_mask=mask.to(device))[0]
+            probs = logits.softmax(dim=-1)
+        fake, real = probs.detach().cpu().flatten().numpy().tolist()
+        self.wfile.write(json.dumps(dict(
+            all_tokens=all_tokens,
+            used_tokens=used_tokens,
+            real_probability=real,
+            fake_probability=fake
+        )).encode())
+    def begin_content(self, content_type):
+        self.send_response(200)
+        self.send_header('Content-Type', content_type)
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.end_headers()
+    def log_message(self, format, *args):
+        log(format % args)
+def serve_forever(server, model, tokenizer, device):
+    log('Process has started; loading the model ...')
+    globals()['model'] = model.to(device)
+    globals()['tokenizer'] = tokenizer
+    globals()['device'] = device
+    log(f'Ready to serve at http://localhost:{server.server_address[1]}')
+    server.serve_forever()
+def main(checkpoint, port=8080, device='cuda' if torch.cuda.is_available() else 'cpu'):
+    if checkpoint.startswith('gs://'):
+        print(f'Downloading {checkpoint}', file=sys.stderr)
+        subprocess.check_output(['gsutil', 'cp', checkpoint, '.'])
+        checkpoint = os.path.basename(checkpoint)
+        assert os.path.isfile(checkpoint)
+    print(f'Loading checkpoint from {checkpoint}')
+    data = torch.load(checkpoint, map_location='cpu')
+    model_name = 'roberta-large' if data['args']['large'] else 'roberta-base'
+    model = RobertaForSequenceClassification.from_pretrained(model_name)
+    tokenizer = RobertaTokenizer.from_pretrained(model_name)
+    model.load_state_dict(data['model_state_dict'])
+    model.eval()
+    print(f'Starting HTTP server on port {port}', file=sys.stderr)
+    server = HTTPServer(('0.0.0.0', port), RequestHandler)
+    # avoid calling CUDA API before forking; doing so in a subprocess is fine.
+    num_workers = int(subprocess.check_output([sys.executable, '-c', 'import torch; print(torch.cuda.device_count())']))
+    if num_workers <= 1:
+        serve_forever(server, model, tokenizer, device)
+    else:
+        print(f'Launching {num_workers} worker processes...')
+        subprocesses = []
+        for i in range(num_workers):
+            os.environ['RANK'] = f'{i}'
+            os.environ['CUDA_VISIBLE_DEVICES'] = f'{i}'
+            process = Process(target=serve_forever, args=(server, model, tokenizer, device))
+            process.start()
+            subprocesses.append(process)
+        del os.environ['RANK']
+        del os.environ['CUDA_VISIBLE_DEVICES']
+        for process in subprocesses:
+            process.join()
+if __name__ == '__main__':
+    fire.Fire(main)