un-gcp-ize

.dockerignore

@@ -0,0 +1,8 @@
+Dockerfile
+.dockerignore
+.gitignore
+.hf_home
+.env
+venv
+COPY_THEN_EDIT.env
+__pycache__

.gitignore

@@ -1,4 +1,5 @@
 __pycache__
 .env
 *.json
-*.ipynb
+*.ipynb
+google/gemma-2b

COPY_THEN_EDIT.env

@@ -0,0 +1,3 @@
+# For Huggingface Spaces, define in `Settings -> Variables and secrets` instead
+
+HUGGINGFACE_TOKEN= # Required

core-model-prediction/Dockerfile → Dockerfile

@@ -7,31 +7,28 @@ WORKDIR /app
 # Copy the current directory contents into the container at /app
 COPY . /app
 
+# For Huggingface
+ENV HF_HOME=/app/.hf_home
+RUN mkdir .hf_home && chmod -R 777 .hf_home
+
 # Install any needed packages specified in requirements.txt
-RUN apt-get update && apt-get install -y unzip \
-    && pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Download Gemma if needed
+# if building locally, use the flag: --secret id=dotenv,src=.env
+# if using HF Spaces, define HUGGINGFACE_TOKEN in Settings -> Variables and secrets
+RUN --mount=type=secret,id=dotenv \
+    --mount=type=secret,id=HUGGINGFACE_TOKEN \
+    python Dockerfile.d/gemma_check.py
 
 # Download NLTK data
 RUN python -m nltk.downloader punkt wordnet averaged_perceptron_tagger
+RUN mv /root/nltk_data /nltk_data
 
 # Unzip wordnet
-RUN unzip /root/nltk_data/corpora/wordnet.zip -d /root/nltk_data/corpora/
-
-# HF Token args
-ARG HF_TOKEN
-
-# Download HuggingFace model
-RUN python -c "from transformers import AutoTokenizer, AutoModelForCausalLM; \
-    tokenizer = AutoTokenizer.from_pretrained('google/gemma-2b', token='$HF_TOKEN'); \
-    model = AutoModelForCausalLM.from_pretrained('google/gemma-2b', token='$HF_TOKEN'); \
-    tokenizer.save_pretrained('/app/gemma-2b'); \
-    model.save_pretrained('/app/gemma-2b')"
-
-# Model env
-ENV MODEL_DIR=gemma-2b
-
-# Make port 8080 available to the world outside this container
-EXPOSE 8080
+RUN apt-get update && apt-get install -y unzip
+RUN unzip /nltk_data/corpora/wordnet.zip -d /nltk_data/corpora/
 
 # Run uvicorn
-CMD ["uvicorn", "prediction:app", "--host", "0.0.0.0", "--port", "8080"]
+EXPOSE 7860
+CMD ["uvicorn", "prediction:app", "--host", "0.0.0.0", "--port", "7860"]

Dockerfile.d/gemma_check.py

@@ -0,0 +1,26 @@
+import os, subprocess
+
+# Check if gemma-2b already exists
+gemma_dir = os.path.join(os.getcwd(), ".hf_home/google/gemma-2b")
+print("Checking", gemma_dir, "...")
+if os.path.isdir(gemma_dir):
+    print("... already exists")
+    exit()
+
+# Check if in a Hunggingface Space
+if os.path.exists("/run/secrets/HUGGINGFACE_TOKEN"):
+    print("... prefetch not needed")
+    exit()
+
+# Check if /run/secrets/dotenv file exists
+if not os.path.isfile("/run/secrets/dotenv"):
+    print("... can't prefetch, can't find --secret dotenv file")
+    exit(1)
+
+# Read the dotenv file and export the variables
+with open("/run/secrets/dotenv") as dotenv_file:
+    for line in dotenv_file:
+        if '=' in line:
+            key, value = line.split("=", 1)
+            os.environ[key.strip()] = value.split("#", 1)[0].strip()
+    subprocess.run(["python", "download-huggingface-model.py", "google/gemma-2b"])

README.md

@@ -1,5 +1,56 @@
+---
+title: Interview AI Detector
+emoji: 🧐
+colorFrom: red
+colorTo: green
+sdk: docker
+pinned: false
+---
+
 # Interview AI Detector
 
+## Playground
+https://panduwana-interview-ai-detector.hf.space/docs
+
+## Dev setup
+Requirements:
+- Python 3.10.x (may have problems with higher versions)
+- Accept the agreement for https://huggingface.co/google/gemma-2b
+
+```
+git clone [email protected]:rekrutmen_plus/interview-ai-detector.git
+cd interview-ai-detector
+```
+
+### With Docker
+<details>
+  <summary>Local build/run</summary>
+  ```
+  cp COPY_THEN_EDIT.env .env # then FILL IT OUT
+  pip install python-dotenv transformers huggingface_hub
+  python download-huggingface-model.py google/gemma-2b
+  docker build -t interview-ai-detector --secret id=dotenv,src=.env .
+  PORT=8080 docker run -p $PORT:7860 interview-ai-detector
+  ```
+  Then open: http://localhost:8080/docs/
+</details>
+<details>
+  <summary>Using Huggingface Spaces</summary>
+  - define a secret: HUGGINGFACE_TOKEN in the space's settings
+  - git push --force
+</details>
+
+### Without Docker
+```
+python --version # ensure 3.10.x
+pip install -r requirements.txt
+python huggingface-download-model.py google/gemma-2b
+python -m nltk.downloader punkt wordnet averaged_perceptron_tagger
+unzip ~/nltk_data/corpora/wordnet.zip -d ~/nltk_data/corpora/
+PORT=8080 uvicorn prediction:app --host 0.0.0.0 --port $PORT
+```
+Then open: http://localhost:8080/docs/
+
 ## Overview
 
 Interview AI Detector is a machine learning model designed to distinguish between human and AI-generated responses during interviews. The system is composed of two models:
@@ -29,7 +80,6 @@ The model is deployed on Google Vertex AI, with integration managed by a Kafka c
 - **Output**: Final prediction indicating whether the response is human or AI-generated
 
 ## Deployment
-
 - **Model Deployment**: Vertex AI
 - **Kafka Consumer Deployment**: Compute Engine
 - **API Framework**: FastAPI
@@ -66,7 +116,6 @@ The model is deployed on Google Vertex AI, with integration managed by a Kafka c
 ## Limitations
 
 - The model is not designed for retraining. The current implementation focuses solely on deployment and prediction.
-- The repository is meant for deployment purposes only and does not support local installation for development.
 
 ## Author
 Yakobus Iryanto Prasethio

cloudbuild.yaml

@@ -1,28 +0,0 @@
-steps:
-  - name: "gcr.io/cloud-builders/docker"
-    dir: "core-model-prediction"
-    entrypoint: "bash"
-    secretEnv: ["_HF_TOKEN"]
-    args: 
-      - -c
-      - | 
-          docker build -t us-central1-docker.pkg.dev/${PROJECT_ID}/interview-ai-detector/model-prediction:latest --build-arg HF_TOKEN=$$_HF_TOKEN .
-
-  - name: "gcr.io/cloud-builders/docker"
-    args:
-      [
-        "push",
-        "us-central1-docker.pkg.dev/${PROJECT_ID}/interview-ai-detector/model-prediction:latest",
-      ]
-
-options:
-  pool:
-    name: 'projects/${PROJECT_ID}/locations/us-central1/workerPools/ai-detector-builder'
-
-images:
-  - "us-central1-docker.pkg.dev/${PROJECT_ID}/interview-ai-detector/model-prediction:latest"
-
-availableSecrets:
-  secretManager:
-    - versionName: "projects/${PROJECT_ID}/secrets/HF_TOKEN/versions/latest"
-      env: "_HF_TOKEN"

core-model-prediction/device_manager.py → device_manager.py

@@ -9,4 +9,5 @@ class DeviceManager:
             cls._instance = super(DeviceManager, cls).__new__(cls)
             cls._instance.device = torch.device(
                 "cuda" if torch.cuda.is_available() else "cpu")
+        print("using c̶p̶u̶ cuda" if torch.cuda.is_available() else "using c̶u̶d̶a̶ cpu")
         return cls._instance.device

download-huggingface-model.py

@@ -0,0 +1,87 @@
+from huggingface_hub import login, model_info, whoami
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from dotenv import load_dotenv
+from datetime import datetime
+import json, argparse, sys, os
+
+def is_interactive():
+    if sys.stdin.isatty():
+        return True
+    return hasattr(sys, 'ps1')
+
+
+def try_interactive_login():
+    try:
+        login()
+    except KeyboardInterrupt:
+        print("^C")
+        exit()
+
+
+def dumps(x):
+    def jsonable(obj):
+        d = {}
+        try:
+            json.dumps(obj)
+        except:
+            if isinstance(obj, datetime):
+                return obj.isoformat()
+            try:
+                d = vars(obj)
+            except:
+                return "..."
+        else:
+            return obj
+        for key, value in d.items():
+            d[key] = jsonable(value)
+        return d
+    return json.dumps(jsonable(x), indent=4, separators=(',', ': '))
+
+parser = argparse.ArgumentParser()
+parser.add_argument('model_id', type=str)
+args = parser.parse_args()
+
+model_id = args.model_id
+path = os.path.join(os.getcwd(), ".hf_home", model_id)
+print("Downloading to", path)
+if os.path.exists(path):
+    print(f"{path} already exists, aborting. (To redownload, rm it first).")
+    exit()
+
+try:
+    model_info(model_id)
+except Exception as e:
+    print(e)
+    exit(1)
+
+try:
+    user_info = whoami()
+except Exception as e:
+    huggingface_token = os.getenv("HUGGINGFACE_TOKEN")
+    if not huggingface_token:
+        load_dotenv()
+        huggingface_token = os.getenv("HUGGINGFACE_TOKEN")
+    if huggingface_token:
+        print("Logging in with env HUGGINGFACE_TOKEN")
+        try:
+            login(huggingface_token)
+        except Exception as e:
+            print(e)
+            try_interactive_login()
+    elif is_interactive():
+        try_interactive_login()
+    else:
+        print("Missing env: HUGGINGFACE_TOKEN")
+        exit(1)
+    user_info = whoami()
+print("Authenticated as:", dumps(user_info))
+
+try:
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    model = AutoModelForCausalLM.from_pretrained(model_id)
+except OSError as e:
+    print(e)
+    exit(1)
+    
+tokenizer.save_pretrained(path)
+model.save_pretrained(path)

core-model-prediction/gemma2b_dependencies.py → gemma2b_dependencies.py

@@ -13,9 +13,9 @@ class Gemma2BDependencies:
     def __new__(cls):
         if cls._instance is None:
             cls._instance = super(Gemma2BDependencies, cls).__new__(cls)
-            model_dir = os.getenv("MODEL_DIR", "gemma-2b")
-            cls._instance.tokenizer = AutoTokenizer.from_pretrained(model_dir, local_files_only=True)
-            cls._instance.model = AutoModelForCausalLM.from_pretrained(model_dir, local_files_only=True)
+            hf_token = os.environ.get('HUGGINGFACE_TOKEN', None)
+            cls._instance.tokenizer = AutoTokenizer.from_pretrained("google/gemma-2b", token=hf_token)
+            cls._instance.model = AutoModelForCausalLM.from_pretrained("google/gemma-2b", token=hf_token)
             cls._instance.device = DeviceManager()
             cls._instance.model.to(cls._instance.device)
         return cls._instance

core-model-prediction/hypothesis.py → hypothesis.py

@@ -15,8 +15,7 @@ import zipfile
 class BaseModelHypothesis:
     def __init__(self):
         self.analyzer = SentimentIntensityAnalyzer()
-        self.lexicon_df = pd.read_csv(
-            "https://storage.googleapis.com/interview-ai-detector/higher-accuracy-final-model/NRC-Emotion-Lexicon.csv")
+        self.lexicon_df = pd.read_csv("NRC-Emotion-Lexicon.csv")
         self.emotion_lexicon = self.process_emotion_lexicon()
         self.lemmatizer = nltk.stem.WordNetLemmatizer()
         self.gemma2bdependencies = Gemma2BDependencies()

core-model-prediction/main_model.py → main_model.py

@@ -3,6 +3,7 @@ from transformers import AlbertModel, AlbertTokenizerFast
 import torch.nn as nn
 import torch
 import numpy as np
+import os
 
 
 class AlbertSeparateTransformation(nn.Module):
@@ -68,7 +69,8 @@ class PredictMainModel:
 
         self.model = AlbertSeparateTransformation(
             self.albert_model).to(self.device)
-        self.model.load_state_dict(torch.load("models/albert_weights.pth"))
+
+        self.model.load_state_dict(torch.load("models/albert_weights.pth", map_location=self.device))
 
     def preprocess_input(self, text: str, additional_features: np.ndarray):
         encoding = self.tokenizer.encode_plus(

public-prediction/get_gpt_answer.py

@@ -1,17 +0,0 @@
-from langchain_openai import ChatOpenAI
-from langchain_core.messages import HumanMessage, SystemMessage
-
-
-class GetGPTAnswer:
-    def __init__(self):
-        self.llm_gpt4o = ChatOpenAI(model="gpt-4o")
-
-    def generate_gpt4o_answer(self, question: str):
-        messages = [
-            SystemMessage(
-                content="Please answer the following question based solely on your internal knowledge, without external references. Assume you are the human."),
-            HumanMessage(question)
-        ]
-
-        gpt4_answer = self.llm_gpt4o.invoke(messages)
-        return gpt4_answer.content

public-prediction/kafka_consumer.py

@@ -1,91 +0,0 @@
-import json
-import os
-import requests
-from kafka import KafkaConsumer
-from get_gpt_answer import GetGPTAnswer
-from typing import List
-from concurrent.futures import ThreadPoolExecutor
-from predict_custom_model import predict_custom_trained_model
-from google.protobuf.json_format import MessageToDict
-
-
-def get_gpt_responses(data: dict[str, any], gpt_helper: GetGPTAnswer):
-    data["gpt4o_answer"] = gpt_helper.generate_gpt4o_answer(data["question"])
-    return data
-
-
-def process_batch(batch: List[dict[str, any]], batch_size: int, gpt_helper: GetGPTAnswer):
-    with ThreadPoolExecutor(max_workers=batch_size) as executor:
-        futures = [executor.submit(
-            get_gpt_responses, data, gpt_helper) for data in batch]
-        results = [future.result() for future in futures]
-
-    predictions = predict_custom_trained_model(
-        instances=results, project=os.environ.get("PROJECT_ID"), endpoint_id=os.environ.get("ENDPOINT_ID"))
-
-    results = []
-    for prediction in predictions:
-        result_dict = {}
-        for key, value in prediction._pb.items():
-            # Ensure that 'value' is a protobuf message
-            if hasattr(value, 'DESCRIPTOR'):
-                result_dict[key] = MessageToDict(value)
-            else:
-                print(f"Item {key} is not a convertible protobuf message.")
-        results.append(result_dict)
-
-    return results
-
-
-def send_results_back(full_results: dict[str, any], job_application_id: str):
-    print(f"Sending results back with job_app_id {job_application_id}")
-    url = "https://ta-2-sistem-cerdas-be-vi2jkj4riq-et.a.run.app/api/anti-cheat/result"
-    headers = {
-        "Content-Type": "application/json",
-        "x-api-key": os.environ.get("X-API-KEY")
-    }
-
-    body = {
-        "job_application_id": job_application_id,
-        "evaluations": full_results
-    }
-
-    response = requests.patch(url, json=body, headers=headers)
-    print(f"Data sent with status code {response.status_code}")
-
-
-def consume_messages():
-    consumer = KafkaConsumer(
-        "ai-detector",
-        bootstrap_servers=[os.environ.get("KAFKA_IP")],
-        auto_offset_reset='earliest',
-        client_id="ai-detector-1",
-        group_id="ai-detector",
-        api_version=(0, 10, 2)
-    )
-
-    print("Successfully connected to Kafka at", os.environ.get("KAFKA_IP"))
-
-    BATCH_SIZE = 5
-    gpt_helper = GetGPTAnswer()
-
-    for message in consumer:
-        try:
-            incoming_message = json.loads(json.loads(message.value.decode("utf-8")))
-            full_batch = incoming_message["data"]
-        except json.JSONDecodeError:
-            print("Failed to decode JSON from message:", message.value)
-            print("Continuing...")
-            continue
-
-        print("Parsing successful. Processing job_app_id {0}".format(
-            incoming_message['job_application_id']))
-
-        full_results = []
-        for i in range(0, len(full_batch), BATCH_SIZE):
-            print(f"Processing batch {i} to {i+BATCH_SIZE}")
-            batch = full_batch[i:i+BATCH_SIZE]
-            batch_results = process_batch(batch, BATCH_SIZE, gpt_helper)
-            full_results.extend(batch_results)
-
-        send_results_back(full_results, incoming_message["job_application_id"])

public-prediction/main.py

@@ -1,6 +0,0 @@
-from kafka_consumer import consume_messages
-from dotenv import load_dotenv
-
-if __name__ == "__main__":
-    load_dotenv()
-    consume_messages()

public-prediction/predict_custom_model.py

@@ -1,42 +0,0 @@
-from typing import Dict, List, Union
-import os
-from google.cloud import aiplatform
-from google.protobuf import json_format
-from google.protobuf.struct_pb2 import Value
-from google.oauth2 import service_account
-
-
-def predict_custom_trained_model(
-    project: str,
-    endpoint_id: str,
-    instances: Union[Dict, List[Dict]],
-    location: str = "us-central1",
-    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
-):
-    """
-    `instances` can be either single instance of type dict or a list
-    of instances.
-    """
-    # The AI Platform services require regional API endpoints.
-    client_options = {"api_endpoint": api_endpoint}
-
-    # Initialize client that will be used to create and send requests.
-    # This client only needs to be created once, and can be reused for multiple requests.
-    client = aiplatform.gapic.PredictionServiceClient(client_options=client_options)
-    # The format of each instance should conform to the deployed model's prediction input schema.
-    instances = instances if isinstance(instances, list) else [instances]
-    instances = [
-        json_format.ParseDict(instance_dict, Value()) for instance_dict in instances
-    ]
-    parameters_dict = {}
-    parameters = json_format.ParseDict(parameters_dict, Value())
-    endpoint = client.endpoint_path(
-        project=project, location=location, endpoint=endpoint_id
-    )
-    response = client.predict(
-        endpoint=endpoint, instances=instances, parameters=parameters
-    )
-    # The predictions are a google.protobuf.Value representation of the model's predictions.
-    predictions = response.predictions
-
-    return predictions

public-prediction/requirements.txt

@@ -1,7 +0,0 @@
-kafka-python
-langchain
-openai
-langchain-openai
-python-dotenv
-google-cloud-aiplatform
-requests

core-model-prediction/requirements.txt → requirements.txt

@@ -1,10 +1,12 @@
 nltk==3.2.4
 vaderSentiment==3.3.2
-pandas
+pandas>=2.2.0,<3.0.0
+numpy==1.26.2
 textstat==0.7.3
 scikit-learn==1.2.2
 transformers==4.38.2
 sentence-transformers==2.7.0
 fastapi
 uvicorn
-google-cloud-secret-manager
+google-cloud-secret-manager
+python-dotenv