Spaces:
Build error
Build error
File size: 4,186 Bytes
c5e4524 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 |
import json
import re
import openai
import pandas as pd
import requests
import spacy
import spacy_transformers
import streamlit_scrollable_textbox as stx
import torch
from sentence_transformers import SentenceTransformer
from tqdm import tqdm
from transformers import (
AutoModelForMaskedLM,
AutoModelForSeq2SeqLM,
AutoTokenizer,
T5ForConditionalGeneration,
T5Tokenizer,
pipeline,
)
import pinecone
import streamlit as st
@st.experimental_singleton
def get_data():
data = pd.read_csv("earnings_calls_cleaned_metadata.csv")
return data
# Initialize Spacy Model
@st.experimental_singleton
def get_spacy_model():
return spacy.load("en_core_web_trf")
@st.experimental_singleton
def get_flan_alpaca_xl_model():
model = AutoModelForSeq2SeqLM.from_pretrained(
"/home/user/app/models/flan-alpaca-xl/"
)
tokenizer = AutoTokenizer.from_pretrained(
"/home/user/app/models/flan-alpaca-xl/"
)
return model, tokenizer
# Initialize models from HuggingFace
@st.experimental_singleton
def get_t5_model():
return pipeline("summarization", model="t5-small", tokenizer="t5-small")
@st.experimental_singleton
def get_flan_t5_model():
tokenizer = T5Tokenizer.from_pretrained("google/flan-t5-large")
model = T5ForConditionalGeneration.from_pretrained("google/flan-t5-large")
return model, tokenizer
@st.experimental_singleton
def get_mpnet_embedding_model():
device = "cuda" if torch.cuda.is_available() else "cpu"
model = SentenceTransformer(
"sentence-transformers/all-mpnet-base-v2", device=device
)
model.max_seq_length = 512
return model
@st.experimental_singleton
def get_splade_sparse_embedding_model():
model_sparse = "naver/splade-cocondenser-ensembledistil"
# check device
device = "cuda" if torch.cuda.is_available() else "cpu"
tokenizer = AutoTokenizer.from_pretrained(model_sparse)
model_sparse = AutoModelForMaskedLM.from_pretrained(model_sparse)
# move to gpu if available
model_sparse.to(device)
return model_sparse, tokenizer
@st.experimental_singleton
def get_sgpt_embedding_model():
device = "cuda" if torch.cuda.is_available() else "cpu"
model = SentenceTransformer(
"Muennighoff/SGPT-125M-weightedmean-nli-bitfit", device=device
)
model.max_seq_length = 512
return model
@st.experimental_memo
def save_key(api_key):
return api_key
# Text Generation
def gpt_model(prompt):
response = openai.Completion.create(
model="text-davinci-003",
prompt=prompt,
temperature=0,
max_tokens=1024,
)
return response.choices[0].text
def generate_text_flan_t5(model, tokenizer, input_text):
input_ids = tokenizer(input_text, return_tensors="pt").input_ids
outputs = model.generate(input_ids, temperature=0.5, max_length=512)
return tokenizer.decode(outputs[0], skip_special_tokens=True)
# Entity Extraction
def generate_entities_flan_alpaca_inference_api(prompt):
API_URL = "https://api-inference.huggingface.co/models/declare-lab/flan-alpaca-xl"
API_TOKEN = st.secrets["hg_key"]
headers = {"Authorization": f"Bearer {API_TOKEN}"}
payload = {
"inputs": prompt,
"parameters": {
"do_sample": True,
"temperature": 0.1,
"max_length": 80,
},
"options": {"use_cache": False, "wait_for_model": True},
}
try:
data = json.dumps(payload)
# Key not used as headers=headers not passed
response = requests.request("POST", API_URL, data=data)
output = json.loads(response.content.decode("utf-8"))[0][
"generated_text"
]
except:
output = ""
print(output)
return output
def generate_entities_flan_alpaca_checkpoint(model, tokenizer, prompt):
model_inputs = tokenizer(prompt, return_tensors="pt")
input_ids = model_inputs["input_ids"]
generation_output = model.generate(
input_ids=input_ids,
temperature=0.1,
top_p=0.5,
max_new_tokens=1024,
)
output = tokenizer.decode(generation_output[0], skip_special_tokens=True)
return output
|