It was just a decade ago when our unsophisticated minds couldn’t conceive the new technological advancements. But the time had to do its talking, and evolution had to be brought in. The thoughts imagined by our futurists needed to be turned into actions for the welfare of human kind. Humans have always faced greater issues in every aspect of life, but healthcare had to be heeded first. We have always imagined a world free of disease where we could guess the cure to every problem before it even occurs. What if this “just” thought of the world can ever be turned into reality? What if the virtual world that we have created can be augmented into the real world? What if Augmented Reality is ever used to its fullest to overcome the biggest hurdle in healthcare?

Defining Augmented Reality (AR)

From the time ‘augmented reality’ was introduced, there have been many questions raised about it. Augmented reality is expounded as an enhanced version of reality where live direct or indirect views of physical real-world environments are augmented with superimposed computer-generated images over a user's view of the real-world, thus enhancing one’s current perception of reality. With the advent of augmented reality, it has broken down several stereotypical hurdles in the world of medicine.

Real-Time Benefits for Healthcare Professionals

Imagine that you walk into your scheduled doctor (or dentist) appointment, only to find your doctor (or dentist) wearing an augmented reality headset (e.g. Google Glass). Although it may look strange, this technology allows him (or her) to access past records, pictures, and other historical data in real-time to discuss with you. Instantly accessing this digital information without having to log into a computer or check a records room proves to be a major benefit to healthcare professionals. Integration of augmented reality-assisted systems with patient record management technologies is already a highly desirable utility. Data integrity and accessibility are major benefits to this type of system, where record access becomes instantaneous and consistent across all professionals to the most current records, instructions, and policies.

Building a PDF Q&A System

The project delves into building a conversational Q&A system to answer questions based on a PDF document. The key steps to be followed are:

• Loading the document: Langchain provides PyPDFLoader to load PDF documents. The method load_and_split allows performing loading and splitting of document texts into small chunks using RecursiveCharacterTextSplitter.

• Implementing a Prompt Template: To get more accurate responses based on the document. A custom prompt template is created that includes context from PDF chunks and the user's question.

• Creating the chat interface: The ConversationalRetrievalChain from LangChain to create the chatbot, which combines the OpenAI language model, the PDF retriever, and the conversation memory.

• Interacting through the interface: Demonstrate how to use the chatbot by asking it a question and displaying the response.

Let's get coding

Diving into the code and understanding the key components:

1. Importing the Necessary Libraries: We start by importing the required libraries, including PyPDFLoader, RecursiveCharacterTextSplitter, PromptTemplate, ChatOpenAI, FAISS, OpenAIEmbeddings, ConversationBufferMemory, and ConversationalRetrievalChain.

#compilation of all libraries
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain
import langchain

2. Loading and Splitting the PDF: This PyPDFLoader is used to load the PDF document and split it into smaller chunks with chunk overlap using the RecursiveCharacterTextSplitter. Thus, ensuring that the chatbot can efficiently retrieve and process the relevant information from the PDF.

langchain.debug=True #used for debugging
loader=PyPDFLoader("input_your.pdf")
pages=loader.load_and_split(RecursiveCharacterTextSplitter(chunk_size=1000,chunk_overlap=100,length_function=len,is_separator_regex=False))
"""to check the splitting and length of the documents, uncomment the below lines."""
#for i in range(0,5):print(i,'Pages response:\n',pages[i])
#print("Total length of pages:",len(pages))

3. Implementing the Prompt Template: To provide the conversational AI system with clear instructions and formatting for the responses, we create a custom prompt template. This template includes placeholders for the context from the PDF chunks and the user's question and specifies the desired response format.

#implementing prompt template for better understanding
#Build prompt
template = """Use the following pieces of context to answer the question at the end.
If you don't know the answer, just say that you don't know, don't try to make up an answer.
Use three sentences maximum. Keep the answer as concise as possible.
Must answer in English language only.
Always say "thanks for asking!" at the end of the answer.
{context}
Question: {question}
Helpful Answer:"""
QA_CHAIN_PROMPT=PromptTemplate(input_variables=["context","question"],template=template)

4. Creating the Conversational system: We use the ConversationalRetrievalChain from LangChain to create the Q&A system. This chain combines the OpenAI language model, the PDF retriever, and the conversation memory. The retriever is created using the FAISS vector store and the OpenAI embeddings, which allows the system to efficiently search and retrieve the relevant information from the PDF.

'''performing embedding to store text in a vectorstore. expose this index in a retriever interface
k=value return the top 2 most similar chunks. create a chain to answer questions'''
qa=ConversationalRetrievalChain.from_llm(ChatOpenAI(model_name="gpt-3.5-turbo-0613",temperature=0,openai_api_key="YOUR_API_KEY"),
                                         retriever=FAISS.from_documents(pages, OpenAIEmbeddings(openai_api_key="YOUR_API_KEY")).as_retriever(search_type="similarity",search_kwargs={"k":2}),
                                         memory=ConversationBufferMemory(k=5,memory_key="chat_history",return_messages=True),
                                         combine_docs_chain_kwargs={"prompt":QA_CHAIN_PROMPT},verbose=True)

4. Interacting with the Q&A: Finally, we demonstrate how to use the Q&A system by asking it a question and displaying the response. The conversational system uses the provided context from the PDF and the user's question to generate a concise and informative answer.

chat_history=[]
query="How to measure quality of AI projects?"
result=qa({"question":query,"chat_history":chat_history})
result["answer"]

Conclusion

In this blog post, we've explored how to build a conversational interface to interact with PDF documents using LangChain and OpenAI. By leveraging the power of LLMs and the LangChain framework, a PDF Q&A system has been created that can provide users with relevant information from the document clearly and concisely. This approach can be extended to handle various types of unstructured data and can be a valuable tool for research, analysis, and knowledge sharing.

Code for creation of Q&A system

What is BERT?

BERT stands for Bidirectional Encoder Representations from Transformers and was introduced under the research paper titled "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding" by Google's AI research team in 2018. It transformed the AI language processing and the way machines understood text. Unlike the traditional models, BERT analyses text bi-directionally to understand the context from the preceding and following words. With the help of a two-step process involving pre-training and fine-tuning BERT can predict missing words in sentences and adapt to various language tasks. Thus making it versatile for different use cases such as sentiment analysis, QnA, Name Entity Recognition(NER) and many more.

Implementation of Sentiment Analysis

As we have gained an overview of the BERT model, let's begin with the implementation of the same.

Working with data and dependencies

The first step is to activate the GPU on the Google Colab notebook and install the necessary dependencies, such as datasets, transformers, and huggingface_hub, to facilitate model training and deployment. Next, we download the IMDB movie review dataset and split it into test and train data, which will then be tokenized using the DistilBERT tokenizer.

Working with the DistilBERT Model

Now that the data is ready, it's time to begin training of BERT model for sentiment analysis. As the BERT model is bulky and quite slow, DistilBERT is used for this project due to the limitations of computational resources in Colab.

Training

We will be using classification tasks for sentiment analysis that enable the transfer of knowledge from DistilBERT to the custom model.

• We import the AutoModelForSequenceClassification class from the transformers library. This class is designed for sequence classification tasks and is compatible with models like BERT.

• We create an instance of the model by calling AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased", num_labels=2). Here, "distilbert-base-uncased" refers to the pre-trained DistilBERT model, and num_labels=2 specifies that we are performing binary sentiment classification (positive or negative sentiment).

• We import TrainingArguments and Trainer API from the transformers library. The TrainingArguments class allows us to define training-related settings.

• We set repo_name to the desired name of the repository where the trained model will be stored.

• We create an instance of TrainingArguments by specifying various training-related settings such as learning rate, batch sizes, gradient accumulation, number of epochs, and more. These settings impact the training process and performance.

• We set push_to_hub=True to indicate that we want to push the trained model to the Hugging Face model hub.

• We initiate the training process using the .train() method of the trainer instance.

• The model begins training based on the specified training arguments and the provided datasets.

• The training loop involves forward and backward passes, gradient updates, and optimization steps.

Evaluation

• We define a custom function compute_metrics that takes the evaluation predictions (eval_pred) as input.

• Inside the function, we load the accuracy and F1 score metrics using load_metric("accuracy") and load_metric("f1").

• We extract the logits and labels from eval_pred and calculate the predictions by selecting the index with the maximum value along the last axis (using np.argmax(logits, axis=-1)).

• We calculate the accuracy and F1 score by passing the predictions and labels to the respective metric calculators and returning them as a dictionary.

• After training, we evaluate the model's performance using the .evaluate() method of the trainer instance.

• This step calculates and displays metrics like accuracy and F1 score based on the evaluation dataset.

Deploying the trained model

While the model can achieve high accuracy it is time for it to be deployed for use by people. When working with the deployment of models HuggingFace offers multiple ways to do so. In this tutorial, we will learn about deploying model through the following methods available on HF:

• Hosted Inference API

• Streamlit app using Spaces

Let's dive deep into the deployment phase:

Hosted Inference API

After pushing the trained model to HF Hub it becomes publicly accessible to the community. We import the pipeline class from the transformers library to simply process performing NLP tasks using pre-trained models. Next, we create a new pipeline sentiment_model where we specify the model's name or identifier.

Finally, we use the sentiment_model pipeline to analyze sentiments on two phrases: "I love this movie" and "This movie sucks!" The model processes these inputs and provides sentiment predictions, which can include labels (e.g., positive-1/negative-0) with prediction accuracy.

Streamlit app with Spaces

• The new Hugging Face (HF) update enables model deployment to production.

• To create an accessible Streamlit app, start by creating a new Space through the Spaces tab on the HuggingFace hub.

• During this process, select the suitable Space SDK from available options, including Streamlit, Gradio, Docker, and Static.

• Since we're focusing on Streamlit, select it as the SDK.

• A default app.py is created, which can be customized to suit our needs for Streamlit app deployment.

• To ensure proper functionality, add a new file named requirements.txt in the Files tab to install the necessary Python dependencies torch and transformers.

• Customize the default app.py file to create your Streamlit web app.

• With these few lines of code, your web app is ready for use.

• To access the app, navigate to the App tab of the Space where it's hosted.

These steps will guide you through the process of deploying your Streamlit app and making it accessible via the Hugging Face model hub.

With this, we end the tutorial on how to implement sentiment analysis by fine-tuning BERT using HuggingFace and deploying through Streamlit. The links to the code for implementation of the same have been provided below:

• Code to sentiment analysis

• Code for model deployment

The booming industries and their sole motive to deliver the most effective and precise product of everything they manufacture need one thing over simply "sensors". They need some instruments which will understand its application even in the foremost tangled places where human intervention is not attainable. This need of the hour might entirely be met by "smart sensors" that have oversized sort of applications along with the advantage of delivering the foremost effective output.

What are Smart Sensors?

A smart sensor could be a device that takes input from the physical environment and intrinsically uses reason resources to perform predefined functions upon detection of specific input and then method information before passing it on. Smart sensors enable a lot of accurate and automated assortment of environmental information with less inaccurate noise amongst the accurately recorded data. This feature permits smart sensors to become at the front of IoT (Internet of things).

The Importance of Smart Sensors in IIoT

The revolutionized industrial world depends on a technology named IIoT (industrial net of things). Smart sensor technologies come back to the forefront once IIoT is enforced these days. IoT sensors comprise self-diagnostics and digital network proficiency that are efficient enough for addressing several processes and distinct industry necessities starting from reducing maintenance to increasing overall equipment effectiveness also as digitally capturing the information of practised personnel. It permits industrial advancements with the assistance of advanced computing, analytics, inexpensive sensing, and new levels of property enabled through the web.

Technologies Supporting the Smart Sensor Revolution

A number of the technologies supporting this revolution area unit cloud services, massive information analytics, and pervasive, intelligent, sensing technologies. The major issue taken into thought for industrial sensible sensors is completely driven by factors like the growing adoption of (System-on-Chip) SoC technology. With the combination of microprocessors and alternative electronic elements, industrial sensible sensors area unit experts in performing important functions like conversion, bi-directional communication, and taking selections in an industrial established.

Benefits of Industrial Smart Sensors

The number of benefits of exploitation System-on-Chip enabled industrial sensible sensors to embrace reduced prices of bulk connectors and cables, higher signal-to-noise quantitative relation, prices improvement, self-calibration, system liableness and multi-sensing at a retail store and intelligent sensors area unit the indispensable enablers of the economic IoT. They establish things, trace them, and confirm their environmental things, all of that has important implications for the production and provide chain. Sensible sensing technology is especially helpful in warehouses as it'll keep track of humidness and temperature, log information for records and quality management, or be adopted as triggers for alarms or method management.

Market Outlook

Overall, the marketplace for sensible sensors is about to ascent, and also the emergence of intelligent sensing element technology is central to sanctioning raised automation.

"AI is the new electricity. It will transform and improve all areas of human life." Andrew Ng

Recently, a new book on building a career in AI was released in December 2022, featuring insights from Andrew Ng, the founder of DeepLearning.AI. I found the book particularly useful as it broke down the career steps in AI into three major categories, namely:

• Learning about AI and gaining new skills

• Working on relevant projects

• Look for jobs accordingly

Learning about AI and gaining skills

• Develop a Strong Foundation in Math and Coding Skills: A strong foundation in mathematics, particularly in linear algebra, calculus, and statistics, is essential to understanding and implementing AI algorithms. Familiarity with crucial programming languages such as Python, R and C++ for building and deploying AI models.

• Learn the Latest Technologies: AI is a rapidly evolving field, and it's important to stay up-to-date with the latest technologies and best practices. This includes familiarizing yourself with popular deep learning frameworks such as TensorFlow, Keras, PyTorch, and Caffe, and understanding the latest advances in areas like computer vision, natural language processing, and reinforcement learning.

Working on relevant projects

• Get Hands-on Experience: One of the best ways to learn about AI is by working on projects. You can gain practical experience by participating in online competitions, hackathons, and open-source projects. This will help you to understand the process of building and deploying AI models, and it will also help you to build your portfolio.

• Specialize: Decide on a specific area of AI that you want to specialize in and focus on it. This could be computer vision, natural language processing, reinforcement learning, or anything else. The more you specialize, the more you will be able to differentiate yourself in the job market.

Look for jobs accordingly

• Network: Connect with other professionals in the field by attending conferences, and meetups, and joining online communities. This will help you to stay informed about the latest developments in AI, and it will also help you to build your professional network.

• Get certified: Consider obtaining a certification in AI to demonstrate your expertise to potential employers.

Overcoming the IMPOSTER SYNDROME

While completing the book, highlighted one of the critical aspects of the success in the AI community, which is IMPOSTER SYNDROME. It is quite common among the people of the community despite being accomplished individuals in their field. It emphasizes that this feeling is common and normal. They encourage newcomers not to be discouraged by these feelings and remind them that everyone struggles with difficult concepts and challenges in AI at some point, but with practice and determination, they will be able to overcome them.