Building ai Chatbot of AI

In this lesson, we will build an effective legal chatbot that uses open tools. Provides a step guide to the action to build Chatbot using the BigScience / T0PP LLM, Kwaighting Face Transformers, and Pytorch. We will visit the model setting on the model, preparation for performance using the pytroch, and to ensure a functional and available legal assistant.

from transformers import AutoModelForSeq2SeqLM, AutoTokenizer


model_name = "bigscience/T0pp"  # Open-source and available
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)

First, we load the BigScience / T0P, open llm, using Face Transformed face. It starts the text tokozer to enter the text to enter the AutodelformB2seQLM, enables the model to perform the text management activities such as answering legal questions.

import spacy
import re


nlp = spacy.load("en_core_web_sm")


def preprocess_legal_text(text):
    text = text.lower()
    text = re.sub(r's+', ' ', text)  # Remove extra spaces
    text = re.sub(r'[^a-zA-Z0-9s]', '', text)  # Remove special characters
    doc = nlp(text)
    tokens = [token.lemma_ for token in doc if not token.is_stop]  # Lemmatization
    return " ".join(tokens)


sample_text = "The contract is valid for 5 years, terminating on December 31, 2025."
print(preprocess_legal_text(sample_text))

After that, we use legal documentation using regular expressions and common expressions to ensure that the purification and planned of NLP functions. It begins converting the text into a small place, removes additional spaces and special characters using regex, and then Tokenizes and lies in the text using the NLP's NLP's NLP pipe. In addition, the words to stop only the logical words, making it good to process legal documentation in AI apps. A cleaned document is effective in the maintenance of the machine and language models such as Bigscience / T0P, which promotes accuracy of legal legal responses.

def extract_legal_entities(text):
    doc = nlp(text)
    entities = [(ent.text, ent.label_) for ent in doc.ents]
    return entities


sample_text = "Apple Inc. signed a contract with Microsoft on June 15, 2023."
print(extract_legal_entities(sample_text))

Here, we release legitimate businesses in the Scriptures for Spay's Antentity Adentity (NEER). The employee processes the installation of the spicy model, pointing and issuing key businesses such as organizations, dates and official names. Returns a list of tuples, each contains the business recognized with its category (eg organization, date, or statutory name).

import faiss
import numpy as np
import torch
from transformers import AutoModel, AutoTokenizer


embedding_model = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
embedding_tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")


def embed_text(text):
    inputs = embedding_tokenizer(text, return_tensors="pt", padding=True, truncation=True)
    with torch.no_grad():
        output = embedding_model(**inputs)
    embedding = output.last_hidden_state.mean(dim=1).squeeze().cpu().numpy()  # Ensure 1D vector
    return embedding


legal_docs = [
    "A contract is legally binding if signed by both parties.",
    "An NDA prevents disclosure of confidential information.",
    "A non-compete agreement prohibits working for a competitor."
]


doc_embeddings = np.array([embed_text(doc) for doc in legal_docs])


print("Embeddings Shape:", doc_embeddings.shape)  # Should be (num_samples, embedding_dim)


index = faiss.IndexFlatL2(doc_embeddings.shape[1])  # Dimension should match embedding size
index.add(doc_embeddings)


query = "What happens if I break an NDA?"
query_embedding = embed_text(query).reshape(1, -1)  # Reshape for FAISS
_, retrieved_indices = index.search(query_embedding, 1)


print(f"Best matching legal text: {legal_docs[retrieved_indices[0][0]]}")

With the code above, we create a restorative documents using faiss to search for Semantic Search. It starts loading model to install face model to produce text prices. EMBED_TEXT function processes official documents and questions by installing the content using the minilm. This embedding is kept in the FASS Vector Index, which allows the same quick search.

def legal_chatbot(query):
    inputs = tokenizer(query, return_tensors="pt", padding=True, truncation=True)
    output = model.generate(**inputs, max_length=100)
    return tokenizer.decode(output[0], skip_special_tokens=True)


query = "What happens if I break an NDA?"
print(legal_chatbot(query))

Finally, we describe the AI ​​legal chatbot as producing responses in legal returns using the original-trained model. Legal_chatbot activity takes a user's question, processing uses Tokenzer, and generates feedback on model. The answer was limited to the text, removing any special tokens. When the question is like “What happens if I break the NNA?” Installing, Chatbot provides the correct answer to AI.

In conclusion, by combining the Bigscience / T0PP LLM, Holding Face Transformed Face, and Pytorch, showed how we can build a powerful and legal chatbot using open resources using open resources. The project is a solid foundation for faithful legal Ai-powered Ai-Powered tools, making legal aid accessible and automatic.

Here is the Colab Notebook of the above project. Also, don't forget to follow Sane and join ours Telegraph station including LinkedIn Grtopic. Don't forget to join ours 80k + ml subreddit.

🚨 Recommended Recommended Research for Nexus