Entity extraction, also known as Named Entity Recognition, is a crucial task in natural language processing that focuses on identifying and classifying key information from unstructured text. This process involves detecting specific entities such as names of people, organizations, locations, dates, and various other categories of information within a body of text. The primary goal of entity extraction is to convert unstructured data into structured formats that can be easily analyzed and interpreted by computers. By transforming raw text into structured data, entity extraction facilitates better information retrieval, content organization, and insights generation from large volumes of textual data.<\/p>\n
Entity extraction using Language Models has emerged as a powerful method for identifying and categorizing entities from unstructured text. Language Models excel in understanding the context surrounding words, which allows them to accurately identify entities based on their usage within sentences. This capability significantly reduces errors associated with ambiguous terms that traditional NER systems might misclassify due to a lack of contextual awareness<\/p>\n
Learning Objectives<\/h3>\n\n- Understand the concept of entity extraction and its role in transforming unstructured text into structured data for better analysis and insights.<\/li>\n
- Explore how small language models enhance entity extraction by leveraging contextual understanding for accurate entity identification.<\/li>\n
- Compare the features, architecture, and performance of small language models like Gemma 2B, Llama 3.2, and Qwen 7B in entity extraction tasks.<\/li>\n
- Learn the process of implementing and evaluating small language models for entity extraction using practical tools like Google Colab and Ollama.<\/li>\n
- Analyze the comparative assessment results to identify the most effective small language models for specific entity extraction scenarios.<\/li>\n<\/ul>\n
This article was published as a part of the\u00a0<\/strong><\/em>Data Science Blogathon.<\/strong><\/em><\/a><\/p>\nEntity extraction has come a long way from traditional rule-based systems to machine learning models, and now to advanced language models. Unlike older methods, which often struggled with ambiguous terms or lacked the flexibility to adapt to new contexts, language models bring a contextual understanding of text. They analyze not just individual words but the relationships between them, allowing for a more accurate identification and classification of entities like names, organizations, locations, and dates.<\/p>\n![\"Why](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/01\/Why-Language-Models-can-improve-Entity-Extraction.webp\")
<\/figure>\nWhat sets language models apart is their ability to leverage vast amounts of training data and sophisticated architectures, like transformer-based designs, to recognize patterns in text. This makes them exceptionally effective in handling complex sentences and detecting subtle variations in how entities are expressed. Whether it\u2019s disambiguating terms like \u201cApple\u201d (the company vs. the fruit) or recognizing new, domain-specific entities without retraining, language models have revolutionized the way unstructured data is transformed into actionable insights. Their adaptability and precision have made them indispensable tools in modern natural language processing.<\/p>\n
Gemma 2B vs Llama 3.2 vs Qwen 7B: Overview<\/h2>\n
Small Language Models have fewer parameters (typically under 10 billion), which dramatically reduces the computational costs and energy usage. They focus on specific tasks and are trained on smaller datasets. This maintains a balance between performance and resource efficiency.\u00a0<\/p>\n![\"Popular](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/01\/Popular-Small-Language-Models.webp\")
<\/figure>\nGemma 2B<\/h3>\n
Gemma 2B is a lightweight, state-of-the-art language model developed by Google, designed to perform effectively across various natural language processing tasks.<\/p>\n
Key Features of Model<\/b><\/p>\n\n- Number of Parameters<\/b>: 2 Billion<\/li>\n
- Context Length<\/b>: 8192 tokens<\/li>\n
- It has been trained on approximately 2 trillion tokens, primarily sourced from web documents, code, and mathematics, predominantly in English.<\/li>\n
- The model is open-source with publicly available weights.<\/li>\n
- Model Architecture<\/b>: Gemma 2B utilizes a decoder-only transformer architecture.<\/li>\n<\/ul>\n
Some other optimizations in the architecture of Gemma 2B are the following:<\/p>\n
\n- Multi-Query Attention (MQA)<\/li>\n
- Rotary Positional Embeddings (RoPE)<\/li>\n
- GeGLU Activations and RMSNorm.<\/li>\n<\/ul>\n
Llama 3.2 1B and 3B<\/h3>\n
Llama 3.2 is a collection of multilingual large language models developed by Meta. It offers various parameter sizes, including the 1 billion (1B) and 3 billion (3B) versions.<\/p>\n
Key Features of Model<\/b><\/p>\n\n- The Llama 3.2 1B model consists of 1.23 billion parameters, while the Llama 3.2 3B model contains approximately 3.2 billion parameters. These lightweight options are suitable for deployment on edge devices and mobile platforms.<\/li>\n
- Context Length for both the models: 128,000 tokens<\/li>\n
- The\u00a0Llama 3.2 1B and 3B\u00a0model was trained on a substantial dataset consisting of up to\u00a09 trillion tokens\u00a0derived from various publicly available sources<\/li>\n
- The Llama 3.2 models are decoder-only transformer models. They are designed as auto-regressive language models, which means they generate text by predicting the next token based on the previous tokens in the sequence.<\/li>\n
- It is optimized for multilingual dialogue use cases, making it suitable for tasks such as retrieval and summarization across various languages<\/li>\n<\/ul>\n
Qwen 7B<\/h3>\n
Alibaba Cloud developed Qwen 7B, a language model designed for a variety of natural language processing tasks.<\/p>\n
Key Features of Model<\/b><\/p>\n\n- Qwen 7B has\u00a07 billion parameters, which allows it to capture complex patterns in language and perform a wide range of tasks effectively.<\/li>\n
- The\u00a0Qwen 7B\u00a0model has a context length of\u00a08,192 tokens<\/li>\n
- The model was pretrained on over\u00a02.4 trillion tokens\u00a0from diverse sources, including web texts, books, and code.<\/li>\n
- Qwen 7B\u00a0model is a\u00a0decoder-only transformer. It is designed similarly to the LLaMA series of models, focusing on generating text by predicting the next token based on previous tokens in the sequence. It consists of 32 layers and 32 attention heads, with a hidden size of 4096, supporting efficient processing of input data.<\/li>\n
- Some other optimizations in the architecture of Gemma 2B are the following:<\/li>\n<\/ul>\n
\n- Rotary Positional Embeddings (RoPE)<\/b><\/li>\n
- SwiGLU activation function <\/b><\/li>\n
- RMSNorm.<\/b><\/li>\n<\/ul>\n
Running models on Google Colab using Ollama provides a seamless way to implement and evaluate small language models for entity extraction tasks. With minimal setup, users can leverage powerful models to process text and extract key entities efficiently.<\/p>\n
Step1: Installing the Required Libraries<\/h3>\n
Below we will install all the required libraries:<\/p>\n
!sudo apt update\n!sudo apt install -y pciutils\n!pip install langchain-ollama\n!pip install ollama==0.4.2<\/code><\/pre>\nStep2: Importing the Required Libraries<\/h3>\n
Once the installation is done, it is time to import the libraries.<\/p>\n
import threading\nimport subprocess\nimport time\nfrom langchain_core.prompts import ChatPromptTemplate\nfrom langchain_ollama.llms import OllamaLLM\nfrom IPython.display import Markdown<\/code><\/pre>\nStep3: Running Ollama in Background on Colab<\/h3>\n
Start the Ollama server in the background on Colab to enable seamless interaction with the language models.<\/p>\n
def run_ollama_serve():\n subprocess.Popen([\"ollama\", \"serve\"])\n\nthread = threading.Thread(target=run_ollama_serve)\nthread.start()\ntime.sleep(5)<\/code><\/pre>\nStep4: Fetching The CSV Data<\/h3>\n
We use the first 10 rows of this dataset<\/a> from github for a comparison of extracted entities as outputs from different small language models.<\/p>\nimport pandas as pd\ndf1 = pd.read_csv(\"generated_highlight_samples.csv\",encoding='latin-1',header=None)\ndf1.columns =['text','entities_org']\ndf1.shape<\/code><\/pre>\nStep5: Pulling Model from Ollama<\/h3>\n
Retrieve the desired language model from Ollama to begin processing text for entity extraction.<\/p>\n
template = \"\"\"Question: {question}\"\"\"\n\nprompt = ChatPromptTemplate.from_template(template)\n\nmodel = OllamaLLM(model=\"mistral\")\n\nchain = prompt | model\n\nfrom tqdm import tqdm\nresp=[]\nfor texts in tqdm(df1['text'].values.tolist()[:10]):\n input_data = {\n \"question\": \"\"\"ONLY EXTRACT \"Project\", \"Companies\" and \"People\" from the following text in the format WITHOUT ANY ADDITIONAL TEXT [\"Project\": \" \" , \"Companies\" : \" \", \"People\" : \" \"] - %s\"\"\"%(texts)}\n\n # Invoke the chain with input data and display the response in Markdown format\n response = chain.invoke(input_data)\n resp.append([texts,response])\n\n# Create DataFrame of Extracted Entities\nresp1 = pd.DataFrame(resp)\nresp1.columns =['Text','Entities']\ndf2 = df1.iloc[:10,:]\nresp1['entities_org']=df2['entities_org'].values.tolist()<\/code><\/pre>\nOutput_from_Gemma 2B<\/h4>\n![\"Output_from_Gemma](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/01\/Output_from_Gemma-2B.webp\")
<\/figure>\nOutput_from_Qwen 7B<\/h4>\n![\"Output_from_Qwen](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/01\/Output_from_Qwen-7B.webp\")
<\/figure>\nOutput_from_Llama 3.2 1 B<\/h4>\n![\"Output_from_Llama](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/01\/Output_from_Llama-3.2-1-B.webp\")
<\/figure>\nOutput_from_Llama 3.2 3 B<\/h4>\n![\"Output_from_Llama](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/01\/Output_from_Llama-3.2-3-B.webp\")
<\/figure>\nThe evaluation framework for assessing entity extraction focuses on measuring the accuracy of identified entities like projects, companies, and people. Each model\u2019s output is scored based on its ability to extract entities correctly, partially, or not at all, with scores aggregated across multiple test cases. This approach ensures a fair comparison of model performance in diverse scenarios.<\/p>\n
This article was published as a part of the\u00a0<\/strong><\/em>Data Science Blogathon.<\/strong><\/em><\/a><\/p>\n Entity extraction has come a long way from traditional rule-based systems to machine learning models, and now to advanced language models. Unlike older methods, which often struggled with ambiguous terms or lacked the flexibility to adapt to new contexts, language models bring a contextual understanding of text. They analyze not just individual words but the relationships between them, allowing for a more accurate identification and classification of entities like names, organizations, locations, and dates.<\/p>\n What sets language models apart is their ability to leverage vast amounts of training data and sophisticated architectures, like transformer-based designs, to recognize patterns in text. This makes them exceptionally effective in handling complex sentences and detecting subtle variations in how entities are expressed. Whether it\u2019s disambiguating terms like \u201cApple\u201d (the company vs. the fruit) or recognizing new, domain-specific entities without retraining, language models have revolutionized the way unstructured data is transformed into actionable insights. Their adaptability and precision have made them indispensable tools in modern natural language processing.<\/p>\n Small Language Models have fewer parameters (typically under 10 billion), which dramatically reduces the computational costs and energy usage. They focus on specific tasks and are trained on smaller datasets. This maintains a balance between performance and resource efficiency.\u00a0<\/p>\n Gemma 2B is a lightweight, state-of-the-art language model developed by Google, designed to perform effectively across various natural language processing tasks.<\/p>\n Key Features of Model<\/b><\/p>\n Some other optimizations in the architecture of Gemma 2B are the following:<\/p>\n Llama 3.2 is a collection of multilingual large language models developed by Meta. It offers various parameter sizes, including the 1 billion (1B) and 3 billion (3B) versions.<\/p>\n Key Features of Model<\/b><\/p>\n Alibaba Cloud developed Qwen 7B, a language model designed for a variety of natural language processing tasks.<\/p>\n Key Features of Model<\/b><\/p>\n Running models on Google Colab using Ollama provides a seamless way to implement and evaluate small language models for entity extraction tasks. With minimal setup, users can leverage powerful models to process text and extract key entities efficiently.<\/p>\n Below we will install all the required libraries:<\/p>\n Once the installation is done, it is time to import the libraries.<\/p>\n Start the Ollama server in the background on Colab to enable seamless interaction with the language models.<\/p>\n We use the first 10 rows of this dataset<\/a> from github for a comparison of extracted entities as outputs from different small language models.<\/p>\n Retrieve the desired language model from Ollama to begin processing text for entity extraction.<\/p>\n The evaluation framework for assessing entity extraction focuses on measuring the accuracy of identified entities like projects, companies, and people. Each model\u2019s output is scored based on its ability to extract entities correctly, partially, or not at all, with scores aggregated across multiple test cases. This approach ensures a fair comparison of model performance in diverse scenarios.<\/p>\n<\/figure>\nGemma 2B vs Llama 3.2 vs Qwen 7B: Overview<\/h2>\n
<\/figure>\nGemma 2B<\/h3>\n
\n
\n
Llama 3.2 1B and 3B<\/h3>\n
\n
Qwen 7B<\/h3>\n
\n
\n
Step1: Installing the Required Libraries<\/h3>\n
!sudo apt update\n!sudo apt install -y pciutils\n!pip install langchain-ollama\n!pip install ollama==0.4.2<\/code><\/pre>\nStep2: Importing the Required Libraries<\/h3>\n
import threading\nimport subprocess\nimport time\nfrom langchain_core.prompts import ChatPromptTemplate\nfrom langchain_ollama.llms import OllamaLLM\nfrom IPython.display import Markdown<\/code><\/pre>\nStep3: Running Ollama in Background on Colab<\/h3>\n
def run_ollama_serve():\n subprocess.Popen([\"ollama\", \"serve\"])\n\nthread = threading.Thread(target=run_ollama_serve)\nthread.start()\ntime.sleep(5)<\/code><\/pre>\nStep4: Fetching The CSV Data<\/h3>\n
import pandas as pd\ndf1 = pd.read_csv(\"generated_highlight_samples.csv\",encoding='latin-1',header=None)\ndf1.columns =['text','entities_org']\ndf1.shape<\/code><\/pre>\nStep5: Pulling Model from Ollama<\/h3>\n
template = \"\"\"Question: {question}\"\"\"\n\nprompt = ChatPromptTemplate.from_template(template)\n\nmodel = OllamaLLM(model=\"mistral\")\n\nchain = prompt | model\n\nfrom tqdm import tqdm\nresp=[]\nfor texts in tqdm(df1['text'].values.tolist()[:10]):\n input_data = {\n \"question\": \"\"\"ONLY EXTRACT \"Project\", \"Companies\" and \"People\" from the following text in the format WITHOUT ANY ADDITIONAL TEXT [\"Project\": \" \" , \"Companies\" : \" \", \"People\" : \" \"] - %s\"\"\"%(texts)}\n\n # Invoke the chain with input data and display the response in Markdown format\n response = chain.invoke(input_data)\n resp.append([texts,response])\n\n# Create DataFrame of Extracted Entities\nresp1 = pd.DataFrame(resp)\nresp1.columns =['Text','Entities']\ndf2 = df1.iloc[:10,:]\nresp1['entities_org']=df2['entities_org'].values.tolist()<\/code><\/pre>\nOutput_from_Gemma 2B<\/h4>\n
<\/figure>\nOutput_from_Qwen 7B<\/h4>\n
<\/figure>\nOutput_from_Llama 3.2 1 B<\/h4>\n
<\/figure>\nOutput_from_Llama 3.2 3 B<\/h4>\n
<\/figure>\n
![\"Nibedita](\"https:\/\/av-eks-lekhak.s3.amazonaws.com\/media\/lekhak-profile-images\/converted_image_ZkJo4gb.webp\")
<\/p>\n