huggingface / cookbook

Open-source AI cookbook

Open-Source AI Cookbook

This repo contains community-driven practical examples of building AI applications and solving various tasks with AI using open-source tools and models.

Contributing to the cookbook

Everyone is welcome to contribute, and we value everybody's contribution! There are several ways you can contribute to the Open-Source AI Cookbook:

• Submit an idea for a desired example/guide via GitHub Issues.
• Contribute a new notebook with a practical example.
• Improve existing examples by fixing issues/typos.

Before contributing, check currently open issues and pull requests to avoid working on something that someone else is already working on.

What makes a good Cookbook notebook?

We believe that the Cookbook will be the most beneficial for everyone in the community if the Jupyter notebooks have the following qualities:

• Practical: Your notebook should provide an illustration of an end-to-end project or a specific aspect of AI development. Aim for real-world applications, but try to avoid overcomplicating. Clearly explain the objectives, challenges and steps involved.
• Build with open-source tools and models: Utilize open source libraries, datasets, and pre-trained models available under permissive licenses. Include links to all resources used within the notebook.
• Clearly written: Ensure your writing is clear, concise, and free from grammatical errors. Maintain a friendly and approachable tone throughout the notebook. Explain the steps you take to solve a problem, challenges, alternative approaches.
• Executes without errors: Test your notebook to avoid runtime errors.
• Adds to existing "recipes": Before submitting, review existing notebooks to confirm that the subject hasn't been covered yet. We welcome diverse use cases, modalities, techniques, and approaches!

Creating a pull request

To contribute a new example/guide, open a pull request, and tag @merveenoyan and @stevhliu.

Here are some tips:

• Make sure that your notebook's file name is in lowercase.
• Don't forget to add your notebook to the _toctree.yml and to index.md.
• Right after the notebook's first header, add yourself as an author like this: _Authored by: [Aymeric Roucher](https://huggingface.co/m-ric)_. You can link to your Hugging Face profile, or to your GitHub profile.
• Remove non-informative code cell outputs (e.g. from pip install). Make sure the notebook doesn't contain any empty code cells.
• If using any images in the markdown, upload them to the huggingface/cookbook-images dataset. Then use the link to the image in your markdown, e.g.: ![RAG diagram](https://huggingface.co/datasets/huggingface/cookbook-images/resolve/main/rag-diagram.png)

Once your pull request is merged, the notebook will show up in the Open-Source AI Cookbook.

Translating the Cookbook into your language

We'd love to have the Cookbook to be available in many more languages! Please follow the steps below if you'd like to help translate the notebooks into your language 🙏.

If some of the notebooks have already been translated into your language, add new translated notebooks under notebooks/your_language. Don't forget to add the new translated notebook to notebooks/your_language/_toctree.yml, and to notebooks/your_language/index.md.

If the notebooks have not yet been translated to your language, create a directory under notebooks with your LANG-ID (e.g. see en for English, zh-CN for Chinese). The LANG-ID should be ISO 639-1 (two lower case letters) language code -- see here for reference. Alternatively, {two lowercase letters}-{two uppercase letters} format is also supported, e.g. zh-CN.

Create the notebooks/LANG-ID/_toctree.yml, and notebooks/LANG-ID/index.md, and add the translated notebook.

Finally, add your language code (the exact same LANG-ID) to the build_documentation.yml and build_pr_documentation.yml files in the .github/workflows folder.

cookbook's Issues

Add instructions on adding notebook translations

Add the instructions for translators to the cookbook readme.
Adapt from here - https://github.com/huggingface/course/blob/main/README.md

Revert #17

Revert #17

Idea for contribution : Recipe on Training FineTuning Embeddings / Re-Rankers on Custom Domain Specific Dataset

Recipe to guide how to prepare data , benchmark to follow , methods to fine tune the bi encoders , cross encoders to adapt the domain specific dataset

Names shouldn't contain emojis

FAISS_with_🤗_datasets_and_CLIP.ipynb could be named to FAISS_with_hf_datasets_and_CLIP.ipynb.

Otherwise, there might be some encoding/decoding issues related to the file name. It will be simpler not to have emojis in file names

cc: @MKhalusova

Translate to Persian/Farsi (Fa)

Hey I'm eager to do a translation into Farsi. If that's ok, Is there any translation-based contribution guide?

Automatic Embeddings: API driven embeddings with TEI and Inference Endpoints

Lets add a notebook around this!

TEI notebook table is out of date

Contribution to Hugging Face 🤗 cookbook: Add a Lang Chain agent that can interact with a PostgreSQL database

We can use the PostgreSQL database to feed additional context to LLMs. However, the naive approach to generating database queries is currently too brittle. Therefore, it is advisable to implement an agent and give it tools to interact with a graph database. The tools use predefined flows and allow agents to solve specific problems. we can use Mixtral 8x7b as an agent.

Translate to Russian (RU)

In this issue, work is underway to translate the following into Russian

Some outputs of code cells don't show up on hf.co/learn

The "Embedding multimodal data for similarity search using 🤗 transformers, 🤗 datasets and FAISS" notebook has images in some outputs which don't show up in the published version.

The "Building A RAG System with Gemma, MongoDB and Open Source Models" notebook has pandas dataframe outputs in some code cells that don't show up in the published version.

It would be great if we could render both types of outputs.

cc @mishig25

Train

I want to train a neural network to automatically compile a table of contents, tell me how to properly mark up documents so that it identifies paragraphs, chapters, page numbers, etc.

Discord channel for Cookbook discussions

@MKhalusova - let me begin by saying thank you. this is an un-issue.

Is there discord channel or huggingface forum set up for discussions related to the cookbook? I've noticed on GitHub recently that there are a few repos that have enabled the discussions feature as well. The LLaVA repo is where I learned about this feature.

The rag_zephyr_langchain.ipynb notebook is great. reinforced and introduced some new concepts.

• faiss-gpu: I had used this python module before on my Windows 11 system and wasn't expecting issues installing it. Simple reason is that I had used it previously from WSL Ubuntu. May be worth mentioning it.

• rag-chain: you may want to mention the essential value provided by LangChain's RunnablePassthrough() method.

  • I'm familiar with LangChain but missed this chapter in my learning process. I don't grok it fully yet but my spidey-sense is telling me it was created to get around challenges related to trying to use f-strings in prompts (it's nasty).

  Thanks again!

Translate to Simplified Chinese (zh-CN)

Hi ! I'm doing some RAG research, and I just found your guys' post on this cookbook tutorial. it was awesome. I want to translate it into Chinese. I'm not sure it is ok.

Contribution to Hugging Face 🤗 cookbook: Add a LangChain agent that can interact with a graph database

You can use more than just vector databases to feed additional context to LLMs. However, the naive approach of generating database queries is too brittle at the moment. Therefore, it is advisable to implement an agent and give it tools to interact with a graph database. The tools use predefined flows and allow agent to solve specific problems. I have a version with OpenAI here: https://towardsdatascience.com/enhancing-interaction-between-language-models-and-graph-databases-via-a-semantic-layer-0a78ad3eba49 Would probably need to use Mixtral 8x7b as an agent.

Quantization Stable Diffusion

I am interested in sharing a notebook about Quantization Stable Diffusion models. It speeds up the performance with lower bit-width and improves efficiency.

PII detection for secure use of LLM api's

I'd love to contribute a PII detection notebook with applications in Finance. Since finance is highly regulated, one of the principal concerns with using any ML endpoints including LLMs is proprietary data being leaked. Some orgs (mine included) use a gateway that filters out PII before hitting the desired endpoint. Wealthsimple has shared a repo on this (https://github.com/wealthsimple/llm-gateway) and if I may contribute, I'll likely make use of their scripts as a starting point and create a walk through covering what using the gateway might look like in an industry setting.

I know that this may not be 100% in the domain of "open-source AI" but given that the biggest barrier most companies face with adopting LLM APIs (at this point, the easiest way for orgs to adopt AI) is the concerns around data privacy, this may encourage adoption faster which can then be a stepping stone towards further ML adoption within the org.

@merveenoyan @stevhliu thoughts?

RAG: Question Answering using Gemma, Elasticsearch & langchain

This is Ashish from Elastic. I'm interested in sharing a notebook that showcases RAG implementation using Elasticsearch. The notebook will illustrate how we generate vectors using Elastic's ELSER model and retrieve semantic results. We'll be utilizing Gemma for contextual question answering.

Contribution to Hugging Face 🤗 cookbook: Utilize advanced retrieval techniques with Hugging Face LLMs for RAG

I would like to contribute to the Hugging Face 🤗 repository by adding a notebook on utilizing different retrieval techniques like BM25 retriever, multi-vector retriever, multi-query retriever, ensemble retriever, and merger retriever on document question answering with Hugging Face 🤗 models as the llms and embedding models.

I've extensively explored langchain's features and would love to contribute to the open source community and share my knowledge.

ValidationError: 1 validation error for agenerate

Hello, @merveenoyan. While my issue isn't directly related to the cookbook, I've encountered an error while using your reference guide for building an instruct dataset using PDFs. I've raised this concern on the agrilla/distilabel repository but haven't received a proper answer yet.

I've attached my notebook along with your cookbook example.
Reference Cookbook Example: https://huggingface.co/learn/cookbook/pipeline_notus_instructions_preferences_legal
Notebook link: https://github.com/KaifAhmad1/code-test/blob/main/Dataset_Creation_using_Distilabel.ipynb

Issue link that I have raised on distilable: argilla-io/distilabel#612

class QuestionAnsweringTask(TextGeneration):
    def generate_prompt(self, question: str) -> str:
        prompt = Prompt(system_prompt=self.system_prompt, formatted_prompt=question)
        formatted_prompt = prompt.format_as("llama2")
        return formatted_prompt

    def parse_output(self, output: str) -> Dict[str, str]:
        return {"answer": output.strip()}

    @property
    def input_args_names(self) -> list[str]:
        return ["question"]

    @property
    def output_args_names(self) -> list[str]:
        return ["answer"]

from distilabel.llms.huggingface import InferenceEndpointsLLM

# Free serverless Inference API
llm = InferenceEndpointsLLM(
    model_id="mistralai/Mistral-7B-Instruct-v0.2",
    api_key="My HF Token"
)
llm.load()

# input 
inputs = [{"question": "What's the second most populated city in Denmark?"}]
generation = llm.generate(inputs)
print(generation[0][0]["parsed_output"]["answer"])

╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ in <cell line: 3>:3                                                                              │
│ ╭─────────────────────────────────────────── locals ───────────────────────────────────────────╮ │
│ │                        Dataset = <class 'datasets.arrow_dataset.Dataset'>                    │ │
│ │                           Dict = typing.Dict                                                 │ │
│ │                       document = [                                                           │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN   EN \n \n \n EUROPEAN             │ │
│ │                                  \nCOMMISSION   \nBrussels, 21.4.2021  \nCOM(2021) 206       │ │
│ │                                  final'+308,                                                 │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 0                                       │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN 1  EN EXPLANATORY MEMORANDUM  \n1. │ │
│ │                                  CONTEXT  OF THE  PROPOSAL  \n1.1. Reasons fo'+3873,         │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 1                                       │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN 2  EN intelligence as stated by    │ │
│ │                                  the European Council3 and ensures the protect'+4148,        │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 2                                       │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN 3  EN proposal takes into account  │ │
│ │                                  the aforementioned resolution of the Europe'+3626,          │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 3                                       │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN 4  EN 1.2. Consistency with        │ │
│ │                                  existing policy pr ovisions in the policy area  \n'+3902,   │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 4                                       │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN 5  EN This proposal is also        │ │
│ │                                  consistent with the applicable Union legislation '+3839,    │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 5                                       │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN 6  EN 2. LEGAL  BASIS,             │ │
│ │                                  SUBSIDIARITY  AND  PROPORTIONALITY  \n2.1. Legal            │ │
│ │                                  basi'+3628,                                                 │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 6                                       │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN 7  EN 2.3. Proportionality  \nThe  │ │
│ │                                  proposal builds on existing legal frameworks'+3464,         │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 7                                       │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN 8  EN academic/research            │ │
│ │                                  institutions, a nd 73 from public authorities. Civil        │ │
│ │                                  '+3721,                                                     │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 8                                       │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN 9  EN In addition, the AI          │ │
│ │                                  Alliance26 was formed as a platform for approximate'+3401,  │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 9                                       │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   ... +98                                                 │ │
│ │                                  ]                                                           │ │
│ │                          drive = <module 'google.colab.drive' from                           │ │
│ │                                  '/usr/local/lib/python3.10/dist-packages/google/colab/driv… │ │
│ │                           exit = <IPython.core.autocall.ZMQExitAutocall object at            │ │
│ │                                  0x7db0dbc37d90>                                             │ │
│ │                    get_ipython = <bound method InteractiveShell.get_ipython of               │ │
│ │                                  <google.colab._shell.Shell object at 0x7db0dbc377f0>>       │ │
│ │                             In = [                                                           │ │
│ │                                  │   '',                                                     │ │
│ │                                  │   "get_ipython().system('pip install -qU distilabel       │ │
│ │                                  langchain pypdf')",                                         │ │
│ │                                  │   'import os\nfrom typing import Dict\nfrom               │ │
│ │                                  distilabel.llms.huggingface import Infere'+120,             │ │
│ │                                  │   'os.environ["HF_TOKEN"] =                               │ │
│ │                                  "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"\nos.environ["HF_'+… │ │
│ │                                  │   'from datasets import Dataset\nfrom                     │ │
│ │                                  langchain_community.document_loaders import Py'+9,          │ │
│ │                                  │   "from google.colab import                               │ │
│ │                                  drive\ndrive.mount('/content/drive')",                      │ │
│ │                                  │   'loader =                                               │ │
│ │                                  PyPDFLoader("/content/drive/MyDrive/EU_AI_Act_Doc.pdf")\nd… │ │
│ │                                  = load'+9,                                                  │ │
│ │                                  │   'print(len(document))',                                 │ │
│ │                                  │   'from langchain.text_splitter import                    │ │
│ │                                  RecursiveCharacterTextSplitter\nMARKDOWN_SEPA'+318,         │ │
│ │                                  │   'splits = text_splitter.split_documents(document)',     │ │
│ │                                  │   ... +46                                                 │ │
│ │                                  ]                                                           │ │
│ │          InferenceEndpointsLLM = <class                                                      │ │
│ │                                  'distilabel.llms.huggingface.inference_endpoints.Inference… │ │
│ │                         inputs = [                                                           │ │
│ │                                  │   {                                                       │ │
│ │                                  │   │   'question': "What's the second most populated city  │ │
│ │                                  in Denmark?"                                                │ │
│ │                                  │   }                                                       │ │
│ │                                  ]                                                           │ │
│ │           instructions_dataset = Dataset({                                                   │ │
│ │                                  │   features: ['input'],                                    │ │
│ │                                  │   num_rows: 50                                            │ │
│ │                                  })                                                          │ │
│ │                            llm = InferenceEndpointsLLM(                                      │ │
│ │                                  │   generation_kwargs={},                                   │ │
│ │                                  │   model_id='mistralai/Mistral-7B-Instruct-v0.2',          │ │
│ │                                  │   endpoint_name=None,                                     │ │
│ │                                  │   endpoint_namespace=None,                                │ │
│ │                                  │                                                           │ │
│ │                                  base_url='https://api-inference.huggingface.co/models/mist… │ │
│ │                                  │   api_key=SecretStr('**********'),                        │ │
│ │                                  │   tokenizer_id=None,                                      │ │
│ │                                  │   model_display_name=None,                                │ │
│ │                                  │   use_openai_client=False                                 │ │
│ │                                  )                                                           │ │
│ │                         loader = <langchain_community.document_loaders.pdf.PyPDFLoader       │ │
│ │                                  object at 0x7db095942c50>                                   │ │
│ │            MARKDOWN_SEPARATORS = [                                                           │ │
│ │                                  │   '\n#{1,6} ',                                            │ │
│ │                                  │   '```\n',                                                │ │
│ │                                  │   '\n\\*\\*\\*+\n',                                       │ │
│ │                                  │   '\n---+\n',                                             │ │
│ │                                  │   '\n___+\n',                                             │ │
│ │                                  │   '\n\n',                                                 │ │
│ │                                  │   '\n',                                                   │ │
│ │                                  │   ' ',                                                    │ │
│ │                                  │   ''                                                      │ │
│ │                                  ]                                                           │ │
│ │                             os = <module 'os' from '/usr/lib/python3.10/os.py'>              │ │
│ │                            Out = {                                                           │ │
│ │                                  │   10: 'EN 6  EN 2. LEGAL  BASIS,  SUBSIDIARITY  AND       │ │
│ │                                  PROPORTIONALITY  \n2.1. Legal  basi'+901,                   │ │
│ │                                  │   11: 'EN   EN \n \n \n EUROPEAN  \nCOMMISSION            │ │
│ │                                  \nBrussels, 21.4.2021  \nCOM(2021) 206 final'+308,          │ │
│ │                                  │   12: Dataset({                                           │ │
│ │                                  │   features: ['input'],                                    │ │
│ │                                  │   num_rows: 50                                            │ │
│ │                                  }),                                                         │ │
│ │                                  │   31: 'EN 6  EN 2. LEGAL  BASIS,  SUBSIDIARITY  AND       │ │
│ │                                  PROPORTIONALITY  \n2.1. Legal  basi'+901,                   │ │
│ │                                  │   32: 'EN   EN \n \n \n EUROPEAN  \nCOMMISSION            │ │
│ │                                  \nBrussels, 21.4.2021  \nCOM(2021) 206 final'+308,          │ │
│ │                                  │   33: Dataset({                                           │ │
│ │                                  │   features: ['input'],                                    │ │
│ │                                  │   num_rows: 50                                            │ │
│ │                                  }),                                                         │ │
│ │                                  │   47: 'EN 6  EN 2. LEGAL  BASIS,  SUBSIDIARITY  AND       │ │
│ │                                  PROPORTIONALITY  \n2.1. Legal  basi'+901,                   │ │
│ │                                  │   48: 'EN   EN \n \n \n EUROPEAN  \nCOMMISSION            │ │
│ │                                  \nBrussels, 21.4.2021  \nCOM(2021) 206 final'+308,          │ │
│ │                                  │   49: Dataset({                                           │ │
│ │                                  │   features: ['input'],                                    │ │
│ │                                  │   num_rows: 50                                            │ │
│ │                                  })                                                          │ │
│ │                                  }                                                           │ │
│ │                       Pipeline = <class 'distilabel.pipeline.local.Pipeline'>                │ │
│ │                    PyPDFLoader = <class                                                      │ │
│ │                                  'langchain_community.document_loaders.pdf.PyPDFLoader'>     │ │
│ │          QuestionAnsweringTask = <class '__main__.QuestionAnsweringTask'>                    │ │
│ │                           quit = <IPython.core.autocall.ZMQExitAutocall object at            │ │
│ │                                  0x7db0dbc37d90>                                             │ │
│ │ RecursiveCharacterTextSplitter = <class                                                      │ │
│ │                                  'langchain_text_splitters.character.RecursiveCharacterText… │ │
│ │                   SelfInstruct = <class 'distilabel.steps.tasks.self_instruct.SelfInstruct'> │ │
│ │                         splits = [                                                           │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN   EN \n \n \n EUROPEAN             │ │
│ │                                  \nCOMMISSION   \nBrussels, 21.4.2021  \nCOM(2021) 206       │ │
│ │                                  final'+305,                                                 │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 0,                                      │ │
│ │                                  │   │   │   'start_index': 0                                │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN 1  EN EXPLANATORY MEMORANDUM  \n1. │ │
│ │                                  CONTEXT  OF THE  PROPOSAL  \n1.1. Reasons fo'+875,          │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 1,                                      │ │
│ │                                  │   │   │   'start_index': 0                                │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='elements and techniques that power    │ │
│ │                                  the socio -economic benefits of AI can also b'+877,         │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 1,                                      │ │
│ │                                  │   │   │   'start_index': 957                              │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='to excellence and trust2. The White   │ │
│ │                                  Paper sets out policy options on how  to ach'+848,          │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 1,                                      │ │
│ │                                  │   │   │   'start_index': 1916                             │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='of fundamental rights. Following the  │ │
│ │                                  publication of the White Paper, the Commiss'+887,           │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 1,                                      │ │
│ │                                  │   │   │   'start_index': 2846                             │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='2 European Commission, White Paper on │ │
│ │                                  Artificial Intelligence - A European appro'+55,             │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 1,                                      │ │
│ │                                  │   │   │   'start_index': 3816                             │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='EN 2  EN intelligence as stated by    │ │
│ │                                  the European Council3 and ensures the protect'+836,         │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 2,                                      │ │
│ │                                  │   │   │   'start_index': 0                                │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='The most recent Conclusi ons from 21  │ │
│ │                                  October 2020  further called for addressing'+876,           │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 2,                                      │ │
│ │                                  │   │   │   'start_index': 919                              │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='resolution includes a text of the     │ │
│ │                                  legislative proposal for a regulation on ethic'+880,        │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 2,                                      │ │
│ │                                  │   │   │   'start_index': 1877                             │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   Document(                                               │ │
│ │                                  │   │   page_content='artificial intelligence -Adoption     │ │
│ │                                  6177/19, 2019.  \n7 European Council, Special '+894,        │ │
│ │                                  │   │   metadata={                                          │ │
│ │                                  │   │   │   'source':                                       │ │
│ │                                  '/content/drive/MyDrive/EU_AI_Act_Doc.pdf',                 │ │
│ │                                  │   │   │   'page': 2,                                      │ │
│ │                                  │   │   │   'start_index': 2839                             │ │
│ │                                  │   │   }                                                   │ │
│ │                                  │   ),                                                      │ │
│ │                                  │   ... +372                                                │ │
│ │                                  ]                                                           │ │
│ │                  text_splitter = <langchain_text_splitters.character.RecursiveCharacterText… │ │
│ │                                  object at 0x7db097424ee0>                                   │ │
│ │                 TextGeneration = <class                                                      │ │
│ │                                  'distilabel.steps.tasks.text_generation.TextGeneration'>    │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                                  │
│ /usr/local/lib/python3.10/dist-packages/distilabel/llms/huggingface/inference_endpoints.py:407   │
│ in generate                                                                                      │
│                                                                                                  │
│   404 │   │   │   ]                                                                              │
│   405 │   │   │   return [outputs[0] for outputs in await asyncio.gather(*tasks)]                │
│   406 │   │                                                                                      │
│ ❱ 407 │   │   outputs = self.event_loop.run_until_complete(agenerate(inputs, **kwargs))          │
│   408 │   │   return list(grouper(outputs, n=num_generations, incomplete="ignore"))              │
│   409                                                                                            │
│                                                                                                  │
│ ╭─────────────────────────────────────────── locals ───────────────────────────────────────────╮ │
│ │       agenerate = <function InferenceEndpointsLLM.generate.<locals>.agenerate at             │ │
│ │                   0x7db0973eb1c0>                                                            │ │
│ │          inputs = [{'question': "What's the second most populated city in Denmark?"}]        │ │
│ │          kwargs = {}                                                                         │ │
│ │ num_generations = 1                                                                          │ │
│ │            self = InferenceEndpointsLLM(                                                     │ │
│ │                   │   generation_kwargs={},                                                  │ │
│ │                   │   model_id='mistralai/Mistral-7B-Instruct-v0.2',                         │ │
│ │                   │   endpoint_name=None,                                                    │ │
│ │                   │   endpoint_namespace=None,                                               │ │
│ │                   │                                                                          │ │
│ │                   base_url='https://api-inference.huggingface.co/models/mistralai/Mistral-7… │ │
│ │                   │   api_key=SecretStr('**********'),                                       │ │
│ │                   │   tokenizer_id=None,                                                     │ │
│ │                   │   model_display_name=None,                                               │ │
│ │                   │   use_openai_client=False                                                │ │
│ │                   )                                                                          │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                                  │
│ /usr/local/lib/python3.10/dist-packages/nest_asyncio.py:98 in run_until_complete                 │
│                                                                                                  │
│    95 │   │   │   if not f.done():                                                               │
│    96 │   │   │   │   raise RuntimeError(                                                        │
│    97 │   │   │   │   │   'Event loop stopped before Future completed.')                         │
│ ❱  98 │   │   │   return f.result()                                                              │
│    99 │                                                                                          │
│   100 │   def _run_once(self):                                                                   │
│   101 │   │   """                                                                                │
│                                                                                                  │
│ ╭─────────────────────────────────────────── locals ───────────────────────────────────────────╮ │
│ │          f = <Task finished name='Task-8'                                                    │ │
│ │              coro=<InferenceEndpointsLLM.generate.<locals>.agenerate() done, defined at      │ │
│ │              /usr/local/lib/python3.10/dist-packages/distilabel/llms/huggingface/inference_… │ │
│ │              exception=1 validation error for agenerate                                      │ │
│ │              input                                                                           │ │
│ │                Input should be a valid list [type=list_type, input_value={'question':        │ │
│ │              "What's the ...lated city in Denmark?"}, input_type=dict]                       │ │
│ │              │   For further information visit https://errors.pydantic.dev/2.7/v/list_type>  │ │
│ │     future = <coroutine object InferenceEndpointsLLM.generate.<locals>.agenerate at          │ │
│ │              0x7db0979c57e0>                                                                 │ │
│ │ manage_run = <function _patch_loop.<locals>.manage_run at 0x7db0ad7fb010>                    │ │
│ │       self = <_UnixSelectorEventLoop running=True closed=False debug=False>                  │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                                  │
│ /usr/lib/python3.10/asyncio/futures.py:201 in result                                             │
│                                                                                                  │
│   198 │   │   │   raise exceptions.InvalidStateError('Result is not ready.')                     │
│   199 │   │   self.__log_traceback = False                                                       │
│   200 │   │   if self._exception is not None:                                                    │
│ ❱ 201 │   │   │   raise self._exception.with_traceback(self._exception_tb)                       │
│   202 │   │   return self._result                                                                │
│   203 │                                                                                          │
│   204 │   def exception(self):                                                                   │
│                                                                                                  │
│ ╭─────────────────────────────────────────── locals ───────────────────────────────────────────╮ │
│ │ self = <Task finished name='Task-8'                                                          │ │
│ │        coro=<InferenceEndpointsLLM.generate.<locals>.agenerate() done, defined at            │ │
│ │        /usr/local/lib/python3.10/dist-packages/distilabel/llms/huggingface/inference_endpoi… │ │
│ │        exception=1 validation error for agenerate                                            │ │
│ │        input                                                                                 │ │
│ │          Input should be a valid list [type=list_type, input_value={'question': "What's the  │ │
│ │        ...lated city in Denmark?"}, input_type=dict]                                         │ │
│ │        │   For further information visit https://errors.pydantic.dev/2.7/v/list_type>        │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                                  │
│ /usr/lib/python3.10/asyncio/tasks.py:232 in __step                                               │
│                                                                                                  │
│   229 │   │   │   if exc is None:                                                                │
│   230 │   │   │   │   # We use the `send` method directly, because coroutines                    │
│   231 │   │   │   │   # don't have `__iter__` and `__next__` methods.                            │
│ ❱ 232 │   │   │   │   result = coro.send(None)                                                   │
│   233 │   │   │   else:                                                                          │
│   234 │   │   │   │   result = coro.throw(exc)                                                   │
│   235 │   │   except StopIteration as exc:                                                       │
│                                                                                                  │
│ ╭─────────────────────────────────────────── locals ───────────────────────────────────────────╮ │
│ │ coro = <coroutine object InferenceEndpointsLLM.generate.<locals>.agenerate at                │ │
│ │        0x7db0979c57e0>                                                                       │ │
│ │ self = None                                                                                  │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                                  │
│ /usr/local/lib/python3.10/dist-packages/distilabel/llms/huggingface/inference_endpoints.py:400   │
│ in agenerate                                                                                     │
│                                                                                                  │
│   397 │   │   │   inputs: List["ChatType"], **kwargs: Any                                        │
│   398 │   │   ) -> "GenerateOutput":                                                             │
│   399 │   │   │   """Internal function to parallelize the asynchronous generation of responses   │
│ ❱ 400 │   │   │   tasks = [                                                                      │
│   401 │   │   │   │   asyncio.create_task(self.agenerate(input=input, **kwargs))                 │
│   402 │   │   │   │   for input in inputs                                                        │
│   403 │   │   │   │   for _ in range(num_generations)                                            │
│                                                                                                  │
│ ╭─────────────────────────────────────────── locals ───────────────────────────────────────────╮ │
│ │          inputs = [{'question': "What's the second most populated city in Denmark?"}]        │ │
│ │          kwargs = {}                                                                         │ │
│ │ num_generations = 1                                                                          │ │
│ │            self = InferenceEndpointsLLM(                                                     │ │
│ │                   │   generation_kwargs={},                                                  │ │
│ │                   │   model_id='mistralai/Mistral-7B-Instruct-v0.2',                         │ │
│ │                   │   endpoint_name=None,                                                    │ │
│ │                   │   endpoint_namespace=None,                                               │ │
│ │                   │                                                                          │ │
│ │                   base_url='https://api-inference.huggingface.co/models/mistralai/Mistral-7… │ │
│ │                   │   api_key=SecretStr('**********'),                                       │ │
│ │                   │   tokenizer_id=None,                                                     │ │
│ │                   │   model_display_name=None,                                               │ │
│ │                   │   use_openai_client=False                                                │ │
│ │                   )                                                                          │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                                  │
│ /usr/local/lib/python3.10/dist-packages/distilabel/llms/huggingface/inference_endpoints.py:401   │
│ in <listcomp>                                                                                    │
│                                                                                                  │
│   398 │   │   ) -> "GenerateOutput":                                                             │
│   399 │   │   │   """Internal function to parallelize the asynchronous generation of responses   │
│   400 │   │   │   tasks = [                                                                      │
│ ❱ 401 │   │   │   │   asyncio.create_task(self.agenerate(input=input, **kwargs))                 │
│   402 │   │   │   │   for input in inputs                                                        │
│   403 │   │   │   │   for _ in range(num_generations)                                            │
│   404 │   │   │   ]                                                                              │
│                                                                                                  │
│ ╭─────────────────────────────────────────── locals ───────────────────────────────────────────╮ │
│ │              .0 = <list_iterator object at 0x7db0957fd210>                                   │ │
│ │           input = {'question': "What's the second most populated city in Denmark?"}          │ │
│ │          kwargs = {}                                                                         │ │
│ │ num_generations = 1                                                                          │ │
│ │            self = InferenceEndpointsLLM(                                                     │ │
│ │                   │   generation_kwargs={},                                                  │ │
│ │                   │   model_id='mistralai/Mistral-7B-Instruct-v0.2',                         │ │
│ │                   │   endpoint_name=None,                                                    │ │
│ │                   │   endpoint_namespace=None,                                               │ │
│ │                   │                                                                          │ │
│ │                   base_url='https://api-inference.huggingface.co/models/mistralai/Mistral-7… │ │
│ │                   │   api_key=SecretStr('**********'),                                       │ │
│ │                   │   tokenizer_id=None,                                                     │ │
│ │                   │   model_display_name=None,                                               │ │
│ │                   │   use_openai_client=False                                                │ │
│ │                   )                                                                          │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                                  │
│ /usr/local/lib/python3.10/dist-packages/pydantic/validate_call_decorator.py:59 in                │
│ wrapper_function                                                                                 │
│                                                                                                  │
│   56 │   │                                                                                       │
│   57 │   │   @functools.wraps(function)                                                          │
│   58 │   │   def wrapper_function(*args, **kwargs):                                              │
│ ❱ 59 │   │   │   return validate_call_wrapper(*args, **kwargs)                                   │
│   60 │   │                                                                                       │
│   61 │   │   wrapper_function.raw_function = function  # type: ignore                            │
│   62                                                                                             │
│                                                                                                  │
│ ╭─────────────────────────────────────────── locals ───────────────────────────────────────────╮ │
│ │                  args = (                                                                    │ │
│ │                         │   InferenceEndpointsLLM(                                           │ │
│ │                         │   │   generation_kwargs={},                                        │ │
│ │                         │   │   model_id='mistralai/Mistral-7B-Instruct-v0.2',               │ │
│ │                         │   │   endpoint_name=None,                                          │ │
│ │                         │   │   endpoint_namespace=None,                                     │ │
│ │                         │   │                                                                │ │
│ │                         base_url='https://api-inference.huggingface.co/models/mistralai/Mis… │ │
│ │                         │   │   api_key=SecretStr('**********'),                             │ │
│ │                         │   │   tokenizer_id=None,                                           │ │
│ │                         │   │   model_display_name=None,                                     │ │
│ │                         │   │   use_openai_client=False                                      │ │
│ │                         │   ),                                                               │ │
│ │                         )                                                                    │ │
│ │                kwargs = {                                                                    │ │
│ │                         │   'input': {                                                       │ │
│ │                         │   │   'question': "What's the second most populated city in        │ │
│ │                         Denmark?"                                                            │ │
│ │                         │   }                                                                │ │
│ │                         }                                                                    │ │
│ │ validate_call_wrapper = <pydantic._internal._validate_call.ValidateCallWrapper object at     │ │
│ │                         0x7db099202a70>                                                      │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                                  │
│ /usr/local/lib/python3.10/dist-packages/pydantic/_internal/_validate_call.py:81 in __call__      │
│                                                                                                  │
│   78 │   │   │   self.__return_pydantic_validator__ = None                                       │
│   79 │                                                                                           │
│   80 │   def __call__(self, *args: Any, **kwargs: Any) -> Any:                                   │
│ ❱ 81 │   │   res = self.__pydantic_validator__.validate_python(pydantic_core.ArgsKwargs(args,    │
│   82 │   │   if self.__return_pydantic_validator__:                                              │
│   83 │   │   │   return self.__return_pydantic_validator__(res)                                  │
│   84 │   │   return res                                                                          │
│                                                                                                  │
│ ╭─────────────────────────────────────────── locals ───────────────────────────────────────────╮ │
│ │   args = (                                                                                   │ │
│ │          │   InferenceEndpointsLLM(                                                          │ │
│ │          │   │   generation_kwargs={},                                                       │ │
│ │          │   │   model_id='mistralai/Mistral-7B-Instruct-v0.2',                              │ │
│ │          │   │   endpoint_name=None,                                                         │ │
│ │          │   │   endpoint_namespace=None,                                                    │ │
│ │          │   │                                                                               │ │
│ │          base_url='https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruc… │ │
│ │          │   │   api_key=SecretStr('**********'),                                            │ │
│ │          │   │   tokenizer_id=None,                                                          │ │
│ │          │   │   model_display_name=None,                                                    │ │
│ │          │   │   use_openai_client=False                                                     │ │
│ │          │   ),                                                                              │ │
│ │          )                                                                                   │ │
│ │ kwargs = {'input': {'question': "What's the second most populated city in Denmark?"}}        │ │
│ │   self = <pydantic._internal._validate_call.ValidateCallWrapper object at 0x7db099202a70>    │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
ValidationError: 1 validation error for agenerate
input
  Input should be a valid list [type=list_type, input_value={'question': "What's the ...lated city in Denmark?"}, 
input_type=dict]
    For further information visit https://errors.pydantic.dev/2.7/v/list_type

Step 5 and Step 6 are out of order in **rag_with_hugging_face_gemma_mongodb.ipynb**

In the rag_with_hugging_face_gemma_mongodb.ipynb notebook, Step 5 is to create a vector search index in the movie_collection_2 MongoDB collection, but this collection has not been created yet in the notebook and it is later created in Step 6. Therefore, I think these two steps are out of order and should be switched.

The notebook is also missing the instructions to create an atlas vector search index in Step 5. It says "Follow instructions here:" but then the next paragraph does not contain instructions.

https://github.com/huggingface/cookbook/blob/main/notebooks/en/rag_with_hugging_face_gemma_mongodb.ipynb

Contribution to Hugging Face 🤗 cookbook: Add two tutorials on Setfit and using HF Inference Endpoints

From Argilla, we would like to contribute with two new tutorials.

• Fine-tune a SetFit model using the ArgillaTrainer: to learn how to use the ArgillaTrainer to fine-tune a SetFit model on a FeedbackDataset made of categorical questions like LabelQuestion and MultiLabelQuestion.
• Create a legal preference dataset: to learn how to use the Notus model on Inference Endpoints to create a legal preference dataset based on RAG instructions from the European AI Act

Structured Text-to-SQL generation using Hugging Face and Outlines

Hi y'all, I thought about writing a notebook that showcases how to create a natural language interface for databases using Hugging Face models, Outlines for structured generation and Lark as a parser for syntax checks.

Outlines is a library that constrain auto-regressive text generation models on outputting text that matches regular expressions, JSON schemas or even grammars, which is pretty amazing.

What do you think @MKhalusova ?

Comprehensive Cookbook for Fine-tuning Gemma Model on Mental Health Assistant Dataset

The cookbook aims to provide a comprehensive guide for researchers and practitioners interested in fine-tuning the Gemma model from Google on a mental health assistant dataset.

Key components of the cookbook include an introduction to the Gemma model, a description of the dataset, preprocessing steps, fine-tuning Gemma using the Hugging Face Transformers library, training procedures, and usage examples. The cookbook will also provide guidance on training parameters, etc. This will help expand the available cookbook resources for leveraging Hugging Face models in various domains.

Usage Examples: Illustrative examples demonstrate how to use the fine-tuned Gemma model for various mental health support tasks, such as response generation.

Manually selectively hide or show cell outputs

Since the notebook will be rendered as doc page. For clarity, we need to manually choose which cell outputs to show or hide.

For example, this is a good cell output that should be left visible. This cell output adds context and necessary information

from FAISS_with_HF_datasets_and_CLIP.ipynb

On the contrary, we should hide this cell output (warnings, install processes, etc)

By hide/show, I mean: make a PR to this repo making necessary changes to the notebooks. You can hide the cell outputs in jupyter notebook. And if necessary, you can change python logging to suppress warnings & only output errors

cc: @MKhalusova @aymeric-roucher

Call for Contributions

Hello folks! 🙋‍♀️
Wanted to post here the roadmap we have for the cookbook. The cookbook is made for industry/applied AI use cases.
In the upcoming weeks, we would like to have more recipes on the following topics:

• Industry-specific recipes: domains like biomedical, legal, finance, and so on require know-how in handling data and the model. You can either contribute an end-to-end Hugging Face example with domain-specific data (can be NLP, computer vision, anything) or demonstrate your library.
• Use cases in other domains: are missing, such as computer vision, multimodal and more. Would be great to have more notebooks.
• Niche techniques built for production: Such as making model faster for real-time prediction with quantization/optimization, or data privacy preservation techniques like federated learning.

In all of above, you can either do Hugging Face e2e workflows or demonstrate your own library or any library you'd like to use.

Feel free to let us know or open a discussion or issue here if you have ideas and you'd like to validate ☺️