demo for Glimpse

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.9
+
+RUN useradd -m -u 1000 gshbao
+USER gshbao
+ENV PATH="/home/gshbao/.local/bin:$PATH"
+
+WORKDIR /glimpse
+
+COPY --chown=gshbao ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=gshbao . /glimpse
+CMD ["bash", "run.sh"]

README.md

@@ -1,12 +1,11 @@
 ---
 title: Glimpse
-emoji: 🌍
-colorFrom: yellow
-colorTo: pink
+emoji: 🏆
+colorFrom: gray
+colorTo: blue
 sdk: docker
 pinned: false
-license: cc
-short_description: 'Glimpse: Enabling White-Box Methods to Use Proprietary Model'
+license: mit
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

api.py

@@ -0,0 +1,80 @@
+import flask
+from flask_cors import CORS
+from concurrent.futures import ThreadPoolExecutor
+import json
+import datetime
+import weave
+from detector_base import get_detector
+
+# app = flask.Flask(__name__)
+app = flask.Flask(__name__, static_folder='./dist', static_url_path='/')
+
+CORS(app, supports_credentials=True)
+executor = ThreadPoolExecutor(10)
+
+def return_data(code, msg, data, cookie="", ToNone=True):
+    if ToNone and len(data) <= 0:
+        data = None
+    jsonStr = {
+        'code': code,
+        'msg': msg,
+        'data': data
+    }
+    response = flask.make_response(flask.jsonify(jsonStr))
+    if cookie:
+        for key, value in cookie.items():
+            response.set_cookie(key, value, max_age=3600 * 12)
+    return response
+
+@weave.op()
+def process_request(text, detector):
+    return detector.compute_prob(text)
+
+def handle_request(detector_name):
+    # request data
+    if flask.request.method == 'POST':
+        try:
+            data = flask.request.data.decode('utf-8')
+        except Exception as ex:
+            print(datetime.datetime.now().isoformat(), ex, flush=True)
+            return return_data(400, 'Bad request', '')
+    else:
+        return return_data(0, '', {})
+    # handle request
+    info = {}
+    sentence = json.loads(data)
+    data = {"sentence": sentence}
+    print(datetime.datetime.now().isoformat(), data, flush=True)
+    try:
+        text = data["sentence"]
+        detector = get_detector(detector_name)
+        future = executor.submit(process_request, text, detector)
+        prob, crit, ntoken = future.result()
+        info["crit"] = crit
+        info["prob"] = prob
+        info["ntoken"] = ntoken
+        print(datetime.datetime.now().isoformat(), info, flush=True)
+        return return_data(0, '', info)
+    except Exception as ex:
+        print(datetime.datetime.now().isoformat(), ex, flush=True)
+        import os
+        os._exit(1)
+        return return_data(400, 'Bad request', '')
+
+
+@app.route("/glimpse", methods=["GET", "POST"])
+def glimpse():
+    return handle_request("glimpse")
+
+@app.route("/", methods=["GET"])
+def index():
+    return app.send_static_file('index.html')
+
+if __name__ == '__main__':
+    # initialize detectors
+    detectors = ['glimpse']
+    for detector_name in detectors:
+        get_detector(detector_name)
+    # service
+    weave.init('Glimpse')
+    app.run(host='0.0.0.0', port=7860)

configs/glimpse.json

@@ -0,0 +1,14 @@
+{
+    "api_base": "${API_BASE}",
+    "api_key": "${API_KEY}",
+    "api_version": "2024-08-01-preview",
+    "scoring_model_name": "davinci-002",
+    "max_token_observed": 512,
+    "estimator": "geometric",
+    "prompt": "prompt3",
+    "rank_size": 1000,
+    "top_k": 5,
+    "linear_k": 1.34,
+    "linear_b": 2.41,
+    "cache_dir": "../cache"
+}

detector_base.py

@@ -0,0 +1,58 @@
+# Copyright (c) Guangsheng Bao.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+import os
+from utils import load_json
+from types import SimpleNamespace
+import numpy as np
+
+def sigmoid(x):
+    return 1 / (1 + np.exp(-x))
+
+class DetectorBase:
+    def __init__(self, config_name):
+        self.config_name = config_name
+        self.config = self.load_config(config_name)
+
+    def load_config(self, config_name):
+        config = load_json(f'./configs/{config_name}.json')
+        for key in config:
+            val = config[key]
+            if type(val) == str and val.startswith('${') and val.endswith('}'):
+                val = os.getenv(val[2:-1])
+                config[key] = val
+                print(f'Config entry solved: {key} -> {val}')
+        return SimpleNamespace(**config)
+
+    def compute_crit(self, text):
+        raise NotImplementedError
+
+    def compute_prob(self, text):
+        crit, ntoken = self.compute_crit(text)
+        prob = sigmoid(self.config.linear_k * crit + self.config.linear_b)
+        return prob, crit, ntoken
+
+    def __str__(self):
+        return self.config_name
+
+
+CACHE_DETECTORS = {}
+
+def get_detector(name):
+    from glimpse import Glimpse
+    name_detectors = {
+        'glimpse': ('glimpse', Glimpse),
+    }
+    # lookup cache
+    global CACHE_DETECTORS
+    if name in CACHE_DETECTORS:
+        return CACHE_DETECTORS[name]
+    # create new
+    if name in name_detectors:
+        config_name, detector_class = name_detectors[name]
+        detector = detector_class(config_name)
+        CACHE_DETECTORS[name] = detector
+        return detector
+    else:
+        raise NotImplementedError

dist/index.html

@@ -0,0 +1 @@
+<!doctype html><html lang="en"><head><meta charset="utf-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width,initial-scale=1"><link rel="icon" href="westlake.png"><title>Demo from Westlake University</title><script defer="defer" src="static/js/app.ffb0b0581194594b.js"></script><link href="static/css/app.fa664689.css" rel="stylesheet"></head><body><noscript><strong>We're sorry but default doesn't work properly without JavaScript enabled. Please enable it to continue.</strong></noscript><div id="app"></div></body></html>

dist/static/js/app.594f31c7f0c0aa9f.js.LICENSE.txt

@@ -0,0 +1,17 @@
+/*!
+ * Vue.js v2.7.16
+ * (c) 2014-2023 Evan You
+ * Released under the MIT License.
+ */
+
+/*!
+* ZRender, a high performance 2d drawing library.
+*
+* Copyright (c) 2013, Baidu Inc.
+* All rights reserved.
+*
+* LICENSE
+* https://github.com/ecomfe/zrender/blob/master/LICENSE.txt
+*/
+
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */

dist/static/js/app.895138338b9a9bfb.js.LICENSE.txt

@@ -0,0 +1,17 @@
+/*!
+ * Vue.js v2.7.16
+ * (c) 2014-2023 Evan You
+ * Released under the MIT License.
+ */
+
+/*!
+* ZRender, a high performance 2d drawing library.
+*
+* Copyright (c) 2013, Baidu Inc.
+* All rights reserved.
+*
+* LICENSE
+* https://github.com/ecomfe/zrender/blob/master/LICENSE.txt
+*/
+
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */

dist/static/js/app.edb5e5e9eac8f89e.js.LICENSE.txt

@@ -0,0 +1,17 @@
+/*!
+ * Vue.js v2.7.16
+ * (c) 2014-2023 Evan You
+ * Released under the MIT License.
+ */
+
+/*!
+* ZRender, a high performance 2d drawing library.
+*
+* Copyright (c) 2013, Baidu Inc.
+* All rights reserved.
+*
+* LICENSE
+* https://github.com/ecomfe/zrender/blob/master/LICENSE.txt
+*/
+
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */

dist/static/js/app.ffb0b0581194594b.js.LICENSE.txt

@@ -0,0 +1,17 @@
+/*!
+ * Vue.js v2.7.16
+ * (c) 2014-2023 Evan You
+ * Released under the MIT License.
+ */
+
+/*!
+* ZRender, a high performance 2d drawing library.
+*
+* Copyright (c) 2013, Baidu Inc.
+* All rights reserved.
+*
+* LICENSE
+* https://github.com/ecomfe/zrender/blob/master/LICENSE.txt
+*/
+
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */

glimpse.py

@@ -0,0 +1,190 @@
+# Copyright (c) Guangsheng Bao.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+import numpy as np
+import json
+import time
+from types import SimpleNamespace
+from detector_base import DetectorBase
+
+
+class OpenAIGPT:
+    def __init__(self, config):
+        self.config = config
+        self.client = self.prepare_client1()
+        # predefined prompts
+        self.prompts = {
+            "prompt0": "",
+            "prompt1": f"You serve as a valuable aide, capable of generating clear and persuasive pieces of writing given a certain context. Now, assume the role of an author and strive to finalize this article.\n",
+            "prompt2": f"You serve as a valuable aide, capable of generating clear and persuasive pieces of writing given a certain context. Now, assume the role of an author and strive to finalize this article.\nI operate as an entity utilizing GPT as the foundational large language model. I function in the capacity of a writer, authoring articles on a daily basis. Presented below is an example of an article I have crafted.\n",
+            "prompt3": f"System:\nYou serve as a valuable aide, capable of generating clear and persuasive pieces of writing given a certain context. Now, assume the role of an author and strive to finalize this article.\nAssistant:\nI operate as an entity utilizing GPT as the foundational large language model. I function in the capacity of a writer, authoring articles on a daily basis. Presented below is an example of an article I have crafted.\n",
+            "prompt4": f"Assistant:\nYou serve as a valuable aide, capable of generating clear and persuasive pieces of writing given a certain context. Now, assume the role of an author and strive to finalize this article.\nUser:\nI operate as an entity utilizing GPT as the foundational large language model. I function in the capacity of a writer, authoring articles on a daily basis. Presented below is an example of an article I have crafted.\n",
+        }
+        self.max_topk = 10
+
+    def prepare_client1(self):
+        api_base = self.config.api_base
+        api_key = self.config.api_key
+        from openai import OpenAI
+        client = OpenAI(
+            base_url=api_base,
+            api_key=api_key)
+        return client
+
+    def prepare_client2(self):
+        api_base = self.config.api_base
+        api_key = self.config.api_key
+        api_version = self.config.api_version
+        from openai import AzureOpenAI
+        client = AzureOpenAI(
+            azure_endpoint=api_base,
+            api_key=api_key,
+            api_version=api_version)
+        return client
+
+    def _response_to_text(self, response):
+        obj = vars(response)
+        text = json.dumps(obj)
+        return text
+
+    def _response_from_text(self, text):
+        obj = json.loads(text)
+        response = SimpleNamespace(**obj)
+        return response
+
+    def evaluate(self, prompt, text):
+        model_name = self.config.scoring_model_name
+        kwargs = {"model": model_name,
+                  "prompt": f"<|endoftext|>{prompt}{text}",
+                  "max_tokens": 0, "echo": True, "logprobs": self.max_topk}
+        # retry 1 time
+        ntry = 2
+        for idx in range(ntry):
+            try:
+                response = self.client.completions.create(**kwargs)
+                response = response.choices[0].logprobs
+                return response
+                break
+            except Exception as e:
+                if idx < ntry - 1:
+                    print(f'{model_name}, {kwargs}: {e}. Retrying ...')
+                    time.sleep(5)
+                    continue
+                raise e
+
+    def eval(self, text):
+        prompt = self.prompts[self.config.prompt]
+        # get top tokens
+        result = self.evaluate(prompt, text)
+        # decide the prefix length
+        prefix = ""
+        nprefix = 1
+        while len(prefix) < len(prompt):
+            prefix += result.tokens[nprefix]
+            nprefix += 1
+        assert prefix == prompt, f"Mismatch: {prompt} .vs. {prefix}"
+        tokens = result.tokens[nprefix:]
+        logprobs = result.token_logprobs[nprefix:]
+        toplogprobs = result.top_logprobs[nprefix:]
+        toplogprobs = [dict(item) for item in toplogprobs]
+        assert len(tokens) == len(logprobs), f"Expected {len(tokens)} logprobs, got {len(logprobs)}"
+        assert len(tokens) == len(toplogprobs), f"Expected {len(tokens)} toplogprobs, got {len(toplogprobs)}"
+        return tokens, logprobs, toplogprobs
+
+# probability distribution estimation
+def safe_log(prob):
+    return np.log(np.array(prob) + 1e-8)
+
+class GeometricDistribution:
+    '''
+    Top-K probabilities: p_1, p_2, ..., p_K
+    Estimated probabilities: Pr(X=k) = p_K * lambda ^ (k - K), for k > K.
+    '''
+    def __init__(self, top_k, rank_size):
+        self.name = "GeometricDistribution"
+        self.top_k = top_k
+        self.rank_size = rank_size
+
+    def estimate_distrib_token(self, toplogprobs):
+        M = self.rank_size  # assuming rank list size
+        K = self.top_k  # assuming top-K tokens
+        assert K <= M
+        toplogprobs = sorted(toplogprobs.values(), reverse=True)
+        assert len(toplogprobs) >= K
+        toplogprobs = toplogprobs[:K]
+        probs = np.exp(toplogprobs)  # distribution over ranks
+        if probs.sum() > 1.0:
+            # print(f'Warnining: Probability {probs.sum()} excels 1.0')
+            probs = probs / (probs.sum() + 1e-6)
+        p_K = probs[-1]  # the k-th top token
+        p_rest = 1 - probs.sum()  # the rest probability mass
+        _lambda = p_rest / (p_K + p_rest)  # approximate the decay factor
+        if _lambda ** (M - K + 1) > 1e-6:
+            # If the condition was not satisfied, use the following code to calculate the decay factor iteratively
+            _lambda_old = _lambda
+            last_diff = 1.0
+            while True:
+                _lambda0 = _lambda
+                minor = _lambda ** (M - K + 1)  # the minor part
+                assert p_rest > 0, f'Error: Invalid p_rest={p_rest}'
+                _lambda = 1 - (_lambda - minor) * p_K / p_rest
+                # check convergence
+                diff = abs(_lambda - _lambda0)
+                if _lambda < 0 or diff < 1e-6 or diff >= last_diff:
+                    _lambda = _lambda0
+                    break
+                last_diff = diff
+            # print(f'Warnining: Invalid lambda={_lambda_old}, re-calculate lambda={_lambda}')
+        assert p_rest >= 0, f'Error: Invalid p_rest={p_rest}'
+        assert 0 <= _lambda <= 1, f'Error: Invalid lambda={_lambda} calculated by p_K={p_K} and p_rest={p_rest}.'
+        # estimate the probabilities of the rest tokens
+        probs_rest = np.exp(safe_log(p_K) + np.arange(1, M - K + 1) * safe_log(_lambda))
+        probs = np.concatenate([probs, probs_rest])
+        # check total probability
+        # if abs(probs.sum() - 1.0) >= 1e-2:
+            # print(f'Warnining: Invalid total probability: {probs.sum()}')
+        probs = probs / probs.sum()
+        return probs.tolist()
+
+class PdeBase:
+    def __init__(self, distrib):
+        self.distrib = distrib
+
+    def estimate_distrib_sequence(self, item):
+        key = f'{self.distrib.name}-top{self.distrib.top_k}'
+        if key in item:
+            probs = item[key]
+        else:
+            toplogprobs = item["toplogprobs"]
+            probs = [self.distrib.estimate_distrib_token(v) for v in toplogprobs]
+            item[key] = probs
+        return np.array(probs)
+
+class PdeFastDetectGPT(PdeBase):
+    def __call__(self, item):
+        logprobs = item["logprobs"]
+        probs = self.estimate_distrib_sequence(item)
+        log_likelihood = np.array(logprobs)
+        lprobs = np.nan_to_num(np.log(probs))
+        mean_ref = (probs * lprobs).sum(axis=-1)
+        lprobs2 = np.nan_to_num(np.square(lprobs))
+        var_ref = (probs * lprobs2).sum(axis=-1) - np.square(mean_ref)
+        discrepancy = (log_likelihood.sum(axis=-1) - mean_ref.sum(axis=-1)) / np.sqrt(var_ref.sum(axis=-1))
+        discrepancy = discrepancy.mean()
+        return discrepancy.item()
+
+
+# the detector
+class Glimpse(DetectorBase):
+    def __init__(self, config_name):
+        super().__init__(config_name)
+        self.gpt = OpenAIGPT(self.config)
+        self.criterion_fn = PdeFastDetectGPT(GeometricDistribution(self.config.top_k, self.config.rank_size))
+
+    def compute_crit(self, text):
+        tokens, logprobs, toplogprobs = self.gpt.eval(text)
+        result = { 'text': text, 'tokens': tokens,
+                   'logprobs': logprobs, 'toplogprobs': toplogprobs}
+        crit = self.criterion_fn(result)
+        return crit, len(tokens)

metrics.py

@@ -0,0 +1,26 @@
+# Copyright (c) Guangsheng Bao.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+import matplotlib.pyplot as plt
+from sklearn.metrics import roc_curve, precision_recall_curve, auc
+
+# 15 colorblind-friendly colors
+COLORS = ["#0072B2", "#009E73", "#D55E00", "#CC79A7", "#F0E442",
+            "#56B4E9", "#E69F00", "#000000", "#0072B2", "#009E73",
+            "#D55E00", "#CC79A7", "#F0E442", "#56B4E9", "#E69F00"]
+
+
+def get_roc_metrics(real_preds, sample_preds):
+    fpr, tpr, _ = roc_curve([0] * len(real_preds) + [1] * len(sample_preds), real_preds + sample_preds)
+    roc_auc = auc(fpr, tpr)
+    return fpr.tolist(), tpr.tolist(), float(roc_auc)
+
+
+def get_precision_recall_metrics(real_preds, sample_preds):
+    precision, recall, _ = precision_recall_curve([0] * len(real_preds) + [1] * len(sample_preds),
+                                                  real_preds + sample_preds)
+    pr_auc = auc(recall, precision)
+    return precision.tolist(), recall.tolist(), float(pr_auc)
+

model.py

@@ -0,0 +1,81 @@
+# Copyright (c) Guangsheng Bao.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import time
+import os
+
+def from_pretrained(cls, model_name, kwargs, cache_dir):
+    # use local model if it exists
+    local_path = os.path.join(cache_dir, model_name.replace("/", "_"))
+    if os.path.exists(local_path):
+        return cls.from_pretrained(local_path, **kwargs)
+    return cls.from_pretrained(model_name, **kwargs, cache_dir=cache_dir)
+
+# predefined models
+model_fullnames = {  'gpt2': 'gpt2',
+                     'gpt2-xl': 'gpt2-xl',
+                     'opt-2.7b': 'facebook/opt-2.7b',
+                     'gpt-neo-2.7B': 'EleutherAI/gpt-neo-2.7B',
+                     'gpt-j-6B': 'EleutherAI/gpt-j-6B',
+                     'gpt-neox-20b': 'EleutherAI/gpt-neox-20b',
+                     'mgpt': 'sberbank-ai/mGPT',
+                     'pubmedgpt': 'stanford-crfm/pubmedgpt',
+                     'mt5-xl': 'google/mt5-xl',
+                     'llama-13b': 'huggyllama/llama-13b',
+                     'llama2-13b': 'TheBloke/Llama-2-13B-fp16',
+                     'bloom-7b1': 'bigscience/bloom-7b1',
+                     'opt-13b': 'facebook/opt-13b',
+                     'falcon-7b': 'falcon-7b',
+                     'falcon-7b-instruct': 'falcon-7b-instruct',
+                     }
+float16_models = ['gpt-neo-2.7B', 'gpt-j-6B', 'gpt-neox-20b', 'llama-13b', 'llama2-13b', 'bloom-7b1', 'opt-13b',
+                  'falcon-7b', 'falcon-7b-instruct']
+
+def get_model_fullname(model_name):
+    return model_fullnames[model_name] if model_name in model_fullnames else model_name
+
+def load_model(model_name, device, cache_dir, is_half=False):
+    model_fullname = get_model_fullname(model_name)
+    print(f'Loading model {model_fullname}...')
+    model_kwargs = {}
+    if model_name in float16_models:
+        model_kwargs.update(dict(torch_dtype=torch.float16))
+    if 'gpt-j' in model_name:
+        model_kwargs.update(dict(revision='float16'))
+    model = from_pretrained(AutoModelForCausalLM, model_fullname, model_kwargs, cache_dir)
+    print('Moving model to GPU...', end='', flush=True)
+    start = time.time()
+    if is_half:
+        model.half()
+    model.to(device)
+    print(f'DONE ({time.time() - start:.2f}s)')
+    return model
+
+def load_tokenizer(model_name, cache_dir):
+    model_fullname = get_model_fullname(model_name)
+    optional_tok_kwargs = {}
+    if "facebook/opt-" in model_fullname:
+        print("Using non-fast tokenizer for OPT")
+        optional_tok_kwargs['fast'] = False
+    optional_tok_kwargs['padding_side'] = 'right'
+    base_tokenizer = from_pretrained(AutoTokenizer, model_fullname, optional_tok_kwargs, cache_dir=cache_dir)
+    if base_tokenizer.pad_token_id is None:
+        base_tokenizer.pad_token_id = base_tokenizer.eos_token_id
+        if '13b' in model_fullname:
+            base_tokenizer.pad_token_id = 0
+    return base_tokenizer
+
+
+if __name__ == '__main__':
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--model_name', type=str, default="bloom-7b1")
+    parser.add_argument('--cache_dir', type=str, default="../cache")
+    args = parser.parse_args()
+
+    load_tokenizer(args.model_name, args.cache_dir)
+    load_model(args.model_name, 'cpu', args.cache_dir)

requirements.txt

@@ -0,0 +1,6 @@
+Flask==3.0.2
+Flask_Cors==4.0.0
+numpy==1.23.5
+openai==1.56.1
+httpx==0.27.2
+weave

run.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+while true
+do
+  echo `date`, START
+  python api.py	
+done
+

utils.py

@@ -0,0 +1,22 @@
+# Copyright (c) Guangsheng Bao.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+import json
+from io import open
+
+def load_json(filename):
+    with open(filename, encoding='utf-8') as f:
+        return json.load(f)
+
+def save_json(filename, data):
+    with open(filename, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+def load_text(filename):
+    with open(filename) as f:
+        return f.read()
+
+def save_text(filename, text):
+    with open(filename, 'w') as f:
+        f.write(text)