Tag: AI

What is Hugging face Transformers?

Hugging Face’s Transformers Library

  • The goal of the Hugging Face Transformers library is to provide a single Python API through which any transformer model can be loaded, trained, fine-tuned and saved.
  • The Hugging Face Transformers library provides thousands of pretrained models to perform tasks on different modalities such as text, vision, and audio. It’s backed by the three most popular deep learning libraries – JAX, PyTorch and TensorFlow.

The pipeline() function

  • The most basic object in the Transformers library is the pipeline() function. It connects a model with its necessary preprocessing and postprocessing steps, allowing us to directly input any text and get an intelligible answer.
  • Some of the text-related tasks available in the pipeline() function are feature extraction, named entity recognition, sentiment analysis, summarization and text generation.
from transformers import pipeline
classifier = pipeline("sentiment-analysis")classifier(    [        sample_text_sequence_1,        sample_text_sequence_2,    ])

Model Hub

  • A model is a general term that can mean either architecture or checkpoint. Architecture refers to the specific neural network configuration uses and checkpoints are the weights for a given architecture. For example, BERT is an architecture, while bert-base-uncased is a checkpoint.
  • The Hugging Face Hub is a platform with over 350k models, 75k datasets, and 150k demo apps, all open source and publicly available, in an online platform from which models can be downloaded from or uploaded to.

Model Cards

  • Model cards are markdown files that accompany the transformer models, provide handy information and are essential for discoverability, reproducibility, and sharing in AI research.
  • Model cards contain additional metadata about the model including and not limited to the model weights, training parameters, training datasets, model performance evaluation results and its intended uses and potential limitations.

Tokenizers

  • Tokenization is an essential step in preprocessing text in Natural Language Processing (NLP) tasks. Tokenizers break down a stream of textual data into words, subwords, or symbols (like punctuation) that can then be converted into numbers or vectors to be processed by algorithms. 
  • A tokenizer in a transformer model is responsible for splitting the input text into tokens, mapping each token to an integer and adding additional inputs that may be useful to the model.

The from_pretrained() method

The from_pretrained() method can be used to load and save a pretrained transformer model. The AutoTokenizer, AutoProcessor and AutoModel classes allow one to load tokenizers, processors and models respectively for any model architecture.

from transformers import AutoModel, AutoTokenizer
checkpoint = 'pretrained-model-you-want'tokenizer = AutoTokenizer.from_pretrained(checkpoint)model = AutoModel.from_pretrained(checkpoint)

Token selection strategies

Decoder models employ various strategies in next token generation, which can be adjusted by the user. These include n-gram penalties, which prevent token sequences of n length from repeating; sampling, which chooses the next token at random from among a collection of likely next tokens; and temperature, which adjusts the predictability of the randomly selected next token, with higher temperatures producing less predictable output.

When decoder models simply select the most probable next token for their output, it’s called “greedy search.” When the model projects several tokens further into the potential output and chooses the most probable multi-token sequence from among several candidates, it’s known as “beam search.”

What is Langchain?

LangChain is a framework designed to simplify the development of applications using large language models (LLMs). It provides tools to connect LLMs with various data sources, manage different components of the workflow, and customize the interaction with these models. Here’s an explanation of LangChain with diagrams to illustrate its core concepts and components.

Core Concepts of LangChain

  1. Prompt Management:
  • LangChain allows developers to manage prompts effectively. This includes templating, formatting, and dynamically generating prompts based on the context.
  1. Chains:
  • Chains are sequences of operations or steps. A chain can be a simple sequence where a prompt is passed to an LLM and the response is processed, or it can be more complex with multiple steps involving different tools or models.
  1. Agents:
  • Agents in LangChain are components that can decide which action to take based on user input. They can dynamically select and run different chains or tools depending on the context.
  1. Memory:
  • LangChain provides mechanisms to maintain state or context across different interactions. This is useful for applications that require the model to remember previous interactions.
  1. Data Augmentation:
  • LangChain integrates with various data sources like databases, APIs, or custom data stores to provide contextually enriched responses.
  1. Tool Integration:
  • LangChain supports the integration of various tools and libraries to extend the functionality of LLMs, such as web scraping tools, search engines, or custom APIs.

Diagram: LangChain Architecture

Below is a simplified diagram illustrating the architecture of LangChain:

Detailed Components

1. Prompt Management

Prompt management involves creating and managing templates that are used to generate the actual prompts sent to the LLM. It includes static prompts, dynamic prompts, and context-based prompts.

+--------------------+
|  Prompt Template   |
+--------------------+
|  "What is the      |
|   capital of {X}?" |
+--------------------+
        |
        v
+--------------------+
|  Generated Prompt  |
+--------------------+
|  "What is the      |
|   capital of France?"|
+--------------------+

2. Chains

Chains define a sequence of operations where each step’s output serves as the next step’s input. They can involve multiple models, tools, or processes.

+---------+      +---------+      +---------+
|  Step 1 |----->|  Step 2 |----->|  Step 3 |
+---------+      +---------+      +---------+

3. Agents

Agents can dynamically choose which chain or tool to execute based on the input they receive.

+-----------+
|   Agent   |
+-----------+
      |
+-----v-----+
|  Decision |
|  Logic    |
+-----+-----+
      |
+-----v-----+
|   Chain   |
|  Selector |
+-----------+

4. Memory

Memory components help maintain context or state across different interactions with the user, allowing for more coherent and context-aware responses.

+-------------+
|  Interaction|
|  History    |
+-------------+
      |
+-----v-----+
|   Memory   |
|   Module   |
+-----------+

5. Data Augmentation

This component integrates external data sources to enrich the information provided by the LLM.

+---------------+
|  External     |
|  Data Source  |
+---------------+
      |
+-----v-----+
| Data      |
| Augmentation |
+-----------+

6. Tool Integration

LangChain can be extended with various tools that perform specific tasks like web scraping, database querying, etc.

+------------+
|   Tool 1   |
+------------+
|   Tool 2   |
+------------+
|   Tool 3   |
+------------+
      |
+-----v-----+
| Integration|
| Module     |
+-----------+

Example Workflow

Here is an example of how these components might work together in a LangChain application:

  1. User Input: The user asks a question.
  2. Prompt Management: The question is formatted using a prompt template.
  3. Chain: The formatted prompt is passed through a chain that might include a language model query, a database lookup, and a final synthesis step.
  4. Memory: The user’s question and the chain’s response are stored in memory for future context.
  5. Data Augmentation: If needed, the chain can pull in additional information from external sources.
  6. Tool Integration: Specific tasks within the chain might call external tools to fetch or process data.
  7. Response: The final, enriched response is returned to the user.

Conclusion

LangChain provides a structured framework for building sophisticated applications with large language models, integrating various tools, managing prompts, and maintaining context across interactions. This modular approach simplifies the development and scalability of LLM-based applications.