from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline
from diffusers import DiffusionPipeline
from transformers import AutoModelForSeq2SeqLM
from samplings import top_p_sampling, temperature_sampling
import torch
from sentence_transformers import SentenceTransformer, util
from datasets import load_dataset
import soundfile as sf
import unicodedata
import itertools
class AIAssistant:
def __init__(self):
pass
## generate regexp for search over memory
def gen_search_expr(self,palabras_unidas):
combinaciones = []
for i in range(1, len(palabras_unidas) + 1):
for combinacion in itertools.combinations(palabras_unidas, i):
regex = ".*?".join(combinacion)
combinaciones.append(regex)
return combinaciones
## join taggued tokens into words
def process_list(self,lista):
palabras_unidas = []
palabra_actual = ""
for token in lista:
if token.startswith("##"):
palabra_actual += token[2:]
else:
if palabra_actual:
palabras_unidas.append(palabra_actual)
palabra_actual = ""
palabra_actual += token
if palabra_actual:
palabras_unidas.append(palabra_actual)
return [unicodedata.normalize("NFKD", palabra).encode("ASCII", "ignore").decode("ASCII").lower() for palabra in palabras_unidas]
## gramatical classificator
def grammatical_pos_tagger(self, text):
nlp_pos = pipeline("token-classification", model="QCRI/bert-base-multilingual-cased-pos-english", tokenizer="QCRI/bert-base-multilingual-cased-pos-english")
res = nlp_pos(text)
return res
## entity classifier
def entity_pos_tagger(self, txt):
tokenizer = AutoTokenizer.from_pretrained("Davlan/bert-base-multilingual-cased-ner-hrl")
model = AutoModelForTokenClassification.from_pretrained("Davlan/bert-base-multilingual-cased-ner-hrl")
nlp = pipeline("ner", model=model, tokenizer=tokenizer)
ner_results = nlp(txt)
return ner_results
## sentiment analysis
def sentiment_tags(self,text):
distilled_student_sentiment_classifier = pipeline(
model="lxyuan/distilbert-base-multilingual-cased-sentiments-student",
return_all_scores=True
)
# english
return distilled_student_sentiment_classifier(text)
## check similarity among sentences (group of tokens (words))
def similarity_tag(self, sentenceA,sentenceB):
res=[]
model = SentenceTransformer('abbasgolestani/ag-nli-bert-mpnet-base-uncased-sentence-similarity-v1')
# Two lists of sentences
#sentences1 = ['I am honored to be given the opportunity to help make our company better',
# 'I love my job and what I do here',
# 'I am excited about our company’s vision']
#sentences2 = ['I am hopeful about the future of our company',
# 'My work is aligning with my passion',
# 'Definitely our company vision will be the next breakthrough to change the world and I’m so happy and proud to work here']
sentences1 = sentenceA
sentences2 = sentenceB
#Compute embedding for both lists
embeddings1 = model.encode(sentences1, convert_to_tensor=True)
embeddings2 = model.encode(sentences2, convert_to_tensor=True)
#Compute cosine-similarities
cosine_scores = util.cos_sim(embeddings1, embeddings2)
#Output the pairs with their score
for i in range(len(sentences1)):
try:
res.append({"A": sentences1[i], "B":sentences2[i], "score":cosine_scores[i][i]})
except:
pass
#print("{} \t\t {} \t\t Score: {:.4f}".format(sentences1[i], sentences2[i], cosine_scores[i][i]))
return res
## text to speech
def texto_to_speech(self,txt):
synthesiser = pipeline("text-to-speech", "microsoft/speecht5_tts")
embeddings_dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")
speaker_embedding = torch.tensor(embeddings_dataset[7306]["xvector"]).unsqueeze(0)
# You can replace this embedding with your own as well.
speech = synthesiser(txt, forward_params={"speaker_embeddings": speaker_embedding})
sf.write("speech.wav", speech["audio"], samplerate=speech["sampling_rate"])
return speech
## text to stable difusor generated image
def text_to_image_generation(self, prompt, n_steps=40, high_noise_frac=0.8):
base = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16, variant="fp16", use_safetensors=True
)
base.to("cuda")
refiner = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-refiner-1.0",
text_encoder_2=base.text_encoder_2,
vae=base.vae,
torch_dtype=torch.float16,
use_safetensors=True,
variant="fp16",
)
refiner.to("cuda")
image = base(
prompt=prompt,
num_inference_steps=n_steps,
denoising_end=high_noise_frac,
output_type="latent",
).images
image = refiner(
prompt=prompt,
num_inference_steps=n_steps,
denoising_start=high_noise_frac,
image=image,
).images[0]
return image
## pass text prompt to music
def text_to_music(self, text, max_length=1024, top_p=0.9, temperature=1.0):
tokenizer = AutoTokenizer.from_pretrained('sander-wood/text-to-music')
model = AutoModelForSeq2SeqLM.from_pretrained('sander-wood/text-to-music')
input_ids = tokenizer(text,
return_tensors='pt',
truncation=True,
max_length=max_length)['input_ids']
decoder_start_token_id = model.config.decoder_start_token_id
eos_token_id = model.config.eos_token_id
decoder_input_ids = torch.tensor([[decoder_start_token_id]])
for t_idx in range(max_length):
outputs = model(input_ids=input_ids,
decoder_input_ids=decoder_input_ids)
probs = outputs.logits[0][-1]
probs = torch.nn.Softmax(dim=-1)(probs).detach().numpy()
sampled_id = temperature_sampling(probs=top_p_sampling(probs,
top_p=top_p,
return_probs=True),
temperature=temperature)
decoder_input_ids = torch.cat((decoder_input_ids, torch.tensor([[sampled_id]])), 1)
if sampled_id!=eos_token_id:
continue
else:
tune = "X:1\n"
tune += tokenizer.decode(decoder_input_ids[0], skip_special_tokens=True)
return tune
break
if __name__ == "__main__":
# Ejemplo de uso
assistant = AIAssistant()
ner_results = assistant.entity_pos_tagger("Nader Jokhadar had given Syria the lead with a well-struck header in the seventh minute.")
print(ner_results)
image = assistant.text_to_image_generation("A majestic lion jumping from a big stone at night")
print(image)
pos_tags = assistant.grammatical_pos_tagger('Mis amigos están pensando en viajar a Londres este verano')
print(pos_tags)
tune = assistant.text_to_music("This is a traditional Irish dance music.")
print(tune)