initial

.gitignore

@@ -0,0 +1,2 @@
+model/
+tokenizer.model

Dockerfile

@@ -0,0 +1,21 @@
+# FROM python:3.8.17
+FROM pytorch/pytorch:2.0.0-cuda11.7-cudnn8-devel
+
+WORKDIR /code
+
+# Get model artifacts from google cloud storage
+RUN echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] http://packages.cloud.google.com/apt cloud-sdk main" | tee -a /etc/apt/sources.list.d/google-cloud-sdk.list && curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key --keyring /usr/share/keyrings/cloud.google.gpg  add - && apt-get update -y && apt-get install google-cloud-cli -y
+      
+COPY ./requirements.txt /code/requirements.txt
+
+RUN apt update
+
+# RUN apt-get install -y python3 python3-pip
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python3", "app.py"]

Readme.md

@@ -0,0 +1,13 @@
+## Introduction 
+
+In the leadup to many US Supreme Court cases, there is often rampant speculation and forecasting by legal experts, the media, and the general public as to what the outcome will be. There is sometimes consensus on the expected rulings, which seem to be based on the existing rulings made by the court and its Justices. Predictions based on existing publicly accessible text? Sounds like a deep learning project! This project makes a rudimentary attempt at predicting the Supreme Court’s ruling on a case when provided a brief overview of the case.
+
+## Training Data
+
+Training data for this project was gathered from Justia using the basic requests library and consists of case summaries and court opinions dating back to 2013 and consists of over 700 cases. I collected both court opinions and the opinions of individual justices, but at the current time only the court opinions were used for fine tuning.
+
+## Model
+The base model is Meta’s Llama2 7B, chosen because it can be trained on an 8GB consumer GPU with quantization. The model finetuning was performed on a laptop RTX 4060 using 4bit normal float quantization and Low-Rank adapters through the Hugging Face transformers and PEFT libraries. LoRA updates were merged with the model following training completion.
+
+## Deployment
+This app runs as a gradio app inside a docker container deployed to Google Cloud Run on a T4 instance. The model weights themselves are stored on Google Cloud storage.

app.py

@@ -0,0 +1,54 @@
+import requests
+import random
+from bs4 import BeautifulSoup
+import time
+import gradio as gr
+
+from config import model_path, tokenizer_path
+from model import Model
+
+class CaseSummaries:
+    def __init__(self):
+        self._case_summaries = None
+
+    @property
+    def case_summaries(self):
+        if self._case_summaries == None:
+            r = requests.get('https://en.wikipedia.org/wiki/List_of_pending_United_States_Supreme_Court_cases')
+            soup = BeautifulSoup(r.content, 'html')
+            self._case_summaries = soup.find_all(True, {'class': ['wikitable', 'sortable', 'jquery-tablesorter']})[0].find_all('tr')[1:]
+        return self._case_summaries
+
+    def random_summary(self) -> str:
+        # function to get a random case summary from wikipedia pending list
+        row:str = random.choice(self.case_summaries)
+        summary = row.find_all('td')[2]
+        summary = summary.get_text()
+        return summary
+    
+
+def run():
+    
+    summaries = CaseSummaries()
+    case_placeholder = summaries.random_summary()
+    model = Model(model_path=model_path, tokenzier_path=tokenizer_path)
+    with gr.Blocks() as demo:
+        cache = gr.Textbox(visible=False)
+        with gr.Row():
+            btn = gr.Button(value="Get Random Case")
+            btn2 = gr.Button(value="Run")
+
+        with gr.Row():
+            txt = gr.Textbox(label="Case Description", lines=15, value=case_placeholder)
+            txt2 = gr.Chatbot(label='Predicted Court Opinion')
+
+
+        btn.click(summaries.random_summary, outputs=[txt], queue=False)
+        # btn2.click(inference, inputs=[txt], outputs=[txt2])
+        btn2.click(lambda x: x, txt, cache, queue=False).then(
+            model.inference, cache, txt2)
+
+    demo.queue().launch(server_name= "0.0.0.0", share=False)
+
+if __name__=='__main__':
+    run()

compose.yaml

@@ -0,0 +1,18 @@
+services:
+  gradio:
+    environment:
+      - ENVIRONMENT=gcp
+    build: 
+      context: .
+      dockerfile: Dockerfile
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]
+    command: python3 app.py
+
+    ports:
+      - "7860:7860"

config.py

@@ -0,0 +1,18 @@
+'''Set ENVIRONMENT to local for local app.py testing and spaces for running from docker image'''
+
+import os
+env  = os.environ.get('ENVIRONMENT', 'local')
+
+if env == 'local':
+    model_path = '../merged_llama2/'
+    tokenizer_path = '../Llama2/7B/tokenizer.model'
+
+elif env == 'spaces':
+    model_path = 'akfung/llama_supreme'
+    tokenizer_path = 'akfung/llama_supreme'
+
+elif env == 'gcp':
+    model_path = 'model/'
+    tokenizer_path = 'tokenizer.model'
+
+max_new_tokens = os.environ.get('max_new_tokens', 100)

get_data.py

@@ -0,0 +1,153 @@
+from bs4 import BeautifulSoup
+import re
+import requests
+import json
+import math
+
+'''Script for scraping and formatting Supreme Court case summaries and court opinions from Justia since 2013'''
+
+def remove_tags(text: str) -> str:
+    '''helper method'''
+    text = re.sub(r'\t|\r', '', text)
+    text = re.sub(r'\n', ' ', text)
+    text.encode('ascii', 'ignore').decode()
+    return text
+
+def clean_soup(url, verbose=False):
+    '''Get docket no, court opinion, and justice opinions for a given case url'''
+
+    r = requests.get(url)
+    soup = BeautifulSoup(r.content, 'html')
+    case_details = dict()
+
+    docket_no = soup.find_all(True, {'class':['flex-col', 'reset-width-below-tablet', 'item']})[0].find_all('span')[0].get_text()
+
+    # get summary. if none, return empty
+    case_summaries = soup.find_all('div', id='summary')
+    if len(case_summaries) == 0:
+        return docket_no, {'summary': 'Dismissed'}
+    case_summary = case_summaries[0].get_text()
+    case_details['summary'] = remove_tags(case_summary)
+    
+    # look for per curiam opinion
+    per_curiam = soup.find_all(True,  {'data-gtm-label':['Opinions Tab - Per Curiam']})
+    if len(per_curiam)>0:
+        opinion = soup.find_all('div',  {'id':re.compile(r'tab-opinion-\d+')})[0]
+        opinion = remove_tags(opinion.get_text())
+        court_opinion_text = re.findall(r'(?<=Per Curiam.)[\w\W]+', opinion)[0].strip()
+        case_details['court_opinion'] = court_opinion_text
+    else:
+    
+        for opinion in soup.find_all('div', {'id': re.compile(r'tab-opinion-')})[1:]:
+
+            opinion = remove_tags(opinion.get_text())
+
+            justice_name = re.findall(r'(?<=Justice\s)\w+', opinion)[0]
+            if verbose:
+                print(justice_name)
+
+            # get court opinion text
+            court_opinion_text = re.findall(r'(?<=delivered the opinion of the Court.)[\w\W]+', opinion)
+
+            if len(court_opinion_text) >0:
+                justice_opinion = court_opinion_text[0].strip()
+                case_details['court_opinion'] = justice_opinion
+                case_details[justice_name] = justice_opinion
+                if verbose:
+                    print(justice_opinion)
+
+            else:
+                justice_opinion =  re.findall(r'((?<=dissenting.)[\w\W]+|(?<=concurring.)[\w\W]+)', opinion)[0].strip()
+                if verbose:
+                    print(justice_opinion)
+                case_details[justice_name] = justice_opinion
+    return docket_no, case_details
+
+if __name__=="__main__":
+    # Scrape case_urls from justia
+
+    years = [f'https://supreme.justia.com/cases/federal/us/year/{i}.html' for i in range(2013, 2024)]
+    case_urls = []
+
+    for year_url in years:
+        r = requests.get(year_url)
+        soup = BeautifulSoup(r.content, 'html')
+        for i in soup.find_all(True,  {'class':['color-green', 'text-soft-wrap']} ):
+            case_urls.append('https://supreme.justia.com' + i.a['href'])
+
+    # scrape cases, track errors
+    case_data = dict()
+    failed_urls = []
+    i = 1
+    for url in case_urls:
+        print(f'Scraping case {i}')
+        try:
+            docket_no, opinions = clean_soup(url)
+            assert opinions
+            case_data[docket_no] = opinions
+        except Exception as e:
+            print(f'Failed on url {url}')
+            failed_urls.append([url, str(e)])
+        
+        i+=1
+
+    # Serialize case_data as json
+    json_object = json.dumps(case_data, indent=4)
+    
+    # Writing to case_data.json
+    with open("case_data.json", "w") as outfile:
+        outfile.write(json_object)
+
+    # Create chunked dataset for hugging face dataloaders
+
+    data = []
+    current = 1
+    max_char = 4000
+    for k,v in case_data.items():
+        print(current)
+        current +=1
+        if v['summary'] != 'Dismissed':
+            summary = re.findall(r'(?<=Justia Summary\s\s\s)[\w\W]+', v['summary'])[0]
+        else:
+            continue
+
+        if v.get('court_opinion')==None:
+
+            continue
+
+        # remove notes from opinion
+        if re.search(r'[\w\W]+(?=Notes 1 \xa0)', v['court_opinion']):
+            court_opinion = re.findall(r'[\w\W]+(?=Notes 1 \xa0)', v['court_opinion'])[0]
+
+        if len(court_opinion) + len(summary) > max_char:
+
+            # chunk the opinions
+            max_len = max_char - len(summary)
+
+            chunk_size = int(max_len/ (math.ceil(max_len/ len(court_opinion))))
+            chunk_suffix = 1
+            for i in range(0, len(court_opinion), chunk_size):
+                chunk = court_opinion[i:i+chunk_size]
+                data.append({
+                    'docket_no': k + str(chunk_suffix),
+                    'summary': summary,
+                    'opinion': chunk
+                })
+
+                chunk_suffix +=1
+        
+        else:
+            data.append({
+                'docket_no': k,
+                'summary': summary,
+                'opinion': v.get('court_opinion', '')
+            })
+
+    dataloader_formatted = dict(
+        version='1.0',
+        data=data
+    )
+
+    json_object = json.dumps(dataloader_formatted, indent=4)
+    with open("chunked_case_data.json", "w") as outfile:
+        outfile.write(json_object)

model.py

@@ -0,0 +1,41 @@
+import torch
+from transformers import LlamaForCausalLM, LlamaTokenizer, BitsAndBytesConfig, TextIteratorStreamer, pipeline
+from threading import Thread
+from config import model_path, tokenizer_path, max_new_tokens
+
+class Model:
+    '''Client class for holding Llama2 model and tokenizer. Models are loaded according to 
+    ENVIRONMENT environment variable
+    '''
+    def __init__(self, 
+                 model_path:str=model_path, 
+                 tokenzier_path:str=tokenizer_path,
+                 max_new_tokens:int=max_new_tokens):
+        self.model_path = model_path
+        self.tokenzier_path = tokenzier_path
+        self.max_new_tokens = max_new_tokens
+        self.bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.float16,
+        )
+        self.model = LlamaForCausalLM.from_pretrained(model_path, quantization_config=self.bnb_config)
+        self.tokenizer = LlamaTokenizer.from_pretrained(tokenzier_path)
+        self.streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True)
+
+
+    def inference(self, query: str):
+        '''Inference function for gradio text streaming'''
+        query = "You are the US Supreme Court. What is your opinion on the following case? " + query
+        batch = self.tokenizer(query, return_tensors='pt')
+
+        generation_kwargs = dict(batch, streamer=self.streamer, max_new_tokens=self.max_new_tokens, repetition_penalty=1.1)
+        thread = Thread(target=self.model.generate, kwargs=generation_kwargs)
+        thread.start()
+
+        output= [[None, '']]
+        
+        for word in self.streamer:
+            output[0][1] += word
+            yield output

requirements.txt

@@ -0,0 +1,11 @@
+requests==2.31.0
+gradio==3.39.0
+beautifulsoup4==4.12.2
+transformers==4.31.0
+torch==2.0.0
+sentencepiece==0.1.99
+regex==2023.6.3
+bitsandbytes==0.39.1
+accelerate==0.20.3
+peft==0.4.0
+scipy==1.10.1