 We need a solution for creating Polish subtitles for YouTube videos in Spanish. The AI should provide the translation.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Video Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Video Classification\', \'api_name\': \'videomae-small-finetuned-ssv2\', \'api_call\': "VideoMAEForVideoClassification.from_pretrained(\'MCG-NJU/videomae-small-finetuned-ssv2\')", \'api_arguments\': {\'model_name\': \'MCG-NJU/videomae-small-finetuned-ssv2\'}, \'python_environment_requirements\': {\'transformers\': \'from transformers import VideoMAEFeatureExtractor, VideoMAEForVideoClassification\', \'numpy\': \'import numpy as np\', \'torch\': \'import torch\'}, \'example_code\': \'video = list(np.random.randn(16, 3, 224, 224))\\nfeature_extractor = VideoMAEFeatureExtractor.from_pretrained(MCG-NJU/videomae-small-finetuned-ssv2)\\nmodel = VideoMAEForVideoClassification.from_pretrained(MCG-NJU/videomae-small-finetuned-ssv2)\\ninputs = feature_extractor(video, return_tensors=pt)\\nwith torch.no_grad():\\n  outputs = model(**inputs)\\n  logits = outputs.logits\\npredicted_class_idx = logits.argmax(-1).item()\\nprint(Predicted class:, model.config.id2label[predicted_class_idx])\', \'performance\': {\'dataset\': \'Something-Something V2\', \'accuracy\': {\'top-1\': 66.8, \'top-5\': 90.3}}, \'description\': \'VideoMAE is an extension of Masked Autoencoders (MAE) to video. The architecture of the model is very similar to that of a standard Vision Transformer (ViT), with a decoder on top for predicting pixel values for masked patches. Videos are presented to the model as a sequence of fixed-size patches (resolution 16x16), which are linearly embedded. One also adds a [CLS] token to the beginning of a sequence to use it for classification tasks. One also adds fixed sinus/cosinus position embeddings before feeding the sequence to the layers of the Transformer encoder. By pre-training the model, it learns an inner representation of videos that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled videos for instance, you can train a standard classifier by placing a linear layer on top of the pre-trained encoder. One typically places a linear layer on top of the [CLS] token, as the last hidden state of this token can be seen as a representation of an entire video.\'}', metadata={})]


 I am an English teacher looking to brainstorm synonyms for the word \"happy.\" Can a model help me generate similar words?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Summarization\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Text-to-Text Generation\', \'api_name\': \'philschmid/bart-large-cnn-samsum\', \'api_call\': "pipeline(\'summarization\', model=\'philschmid/bart-large-cnn-samsum\')", \'api_arguments\': {\'model\': \'philschmid/bart-large-cnn-samsum\'}, \'python_environment_requirements\': {\'transformers\': \'latest\'}, \'example_code\': "from transformers import pipeline\\nsummarizer = pipeline(summarization, model=philschmid/bart-large-cnn-samsum)\\nconversation = \'\'\'Jeff: Can I train a 🤗 Transformers model on Amazon SageMaker? \\nPhilipp: Sure you can use the new Hugging Face Deep Learning Container. \\nJeff: ok.\\nJeff: and how can I get started? \\nJeff: where can I find documentation? \\nPhilipp: ok, ok you can find everything here. https://huggingface.co/blog/the-partnership-amazon-sagemaker-and-hugging-face <br />\\n\'\'\'\\nsummarizer(conversation)", \'performance\': {\'dataset\': \'samsum\', \'accuracy\': {\'eval_rouge1\': 42.621, \'eval_rouge2\': 21.9825, \'eval_rougeL\': 33.034, \'eval_rougeLsum\': 39.6783, \'test_rouge1\': 41.3174, \'test_rouge2\': 20.8716, \'test_rougeL\': 32.1337, \'test_rougeLsum\': 38.4149}}, \'description\': \'philschmid/bart-large-cnn-samsum is a BART-based model trained for text summarization on the SAMSum dataset. It can be used to generate abstractive summaries of conversations.\'}', metadata={})]


 Generate a sentence which will complete the following: \"Hello, I'm a ...\"\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Fill-Mask\', \'framework\': \'Transformers\', \'functionality\': \'Fill-Mask\', \'api_name\': \'distilbert-base-uncased\', \'api_call\': "pipeline(\'fill-mask\', model=\'distilbert-base-uncased\')", \'api_arguments\': {\'model\': \'distilbert-base-uncased\'}, \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import pipeline\\nunmasker = pipeline(\'fill-mask\', model=\'distilbert-base-uncased\')\\nunmasker(Hello I\'m a [MASK] model.)", \'performance\': {\'dataset\': \'GLUE\', \'accuracy\': {\'MNLI\': 82.2, \'QQP\': 88.5, \'QNLI\': 89.2, \'SST-2\': 91.3, \'CoLA\': 51.3, \'STS-B\': 85.8, \'MRPC\': 87.5, \'RTE\': 59.9}}, \'description\': "DistilBERT is a transformers model, smaller and faster than BERT, which was pretrained on the same corpus in a self-supervised fashion, using the BERT base model as a teacher. It was pretrained with three objectives: Distillation loss, Masked language modeling (MLM), and Cosine embedding loss. This model is uncased and can be used for masked language modeling or next sentence prediction, but it\'s mostly intended to be fine-tuned on a downstream task."}', metadata={})]


 Can you help me find the best model to fill in the gap in my legal document? I want a smaller model with higher efficiency but maintains a high level of accuracy.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Summarization\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Text Summarization\', \'api_name\': \'distilbart-cnn-12-6-samsum\', \'api_call\': "pipeline(\'summarization\', model=\'philschmid/distilbart-cnn-12-6-samsum\')", \'api_arguments\': {\'model\': \'philschmid/distilbart-cnn-12-6-samsum\'}, \'python_environment_requirements\': \'transformers\', \'example_code\': "from transformers import pipeline\\nsummarizer = pipeline(summarization, model=philschmid/distilbart-cnn-12-6-samsum)\\nconversation = \'\'\'Jeff: Can I train a 🤗 Transformers model on Amazon SageMaker? \\nPhilipp: Sure you can use the new Hugging Face Deep Learning Container. \\nJeff: ok.\\nJeff: and how can I get started? \\nJeff: where can I find documentation? \\nPhilipp: ok, ok you can find everything here. https://huggingface.co/blog/the-partnership-amazon-sagemaker-and-hugging-face <br />\\n\'\'\'\\nsummarizer(conversation)", \'performance\': {\'dataset\': \'samsum\', \'accuracy\': {\'ROUGE-1\': 41.09, \'ROUGE-2\': 20.746, \'ROUGE-L\': 31.595, \'ROUGE-LSUM\': 38.339}}, \'description\': \'This model is a DistilBART-based text summarization model trained on the SAMsum dataset. It can be used to generate summaries of conversational text.\'}', metadata={})]


 I am learning English literature. I plan to build a system that has a huge database of English sentences and keeps the important ones.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Transformers\', \'functionality\': \'Sentence Correction\', \'api_name\': \'flexudy/t5-base-multi-sentence-doctor\', \'api_call\': "AutoModelWithLMHead.from_pretrained(\'flexudy/t5-base-multi-sentence-doctor\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'from transformers import AutoTokenizer, AutoModelWithLMHead\\ntokenizer = AutoTokenizer.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\nmodel = AutoModelWithLMHead.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\ninput_text = repair_sentence: m a medical doct context: {That is my job I a}{or I save lives} </s>\\ninput_ids = tokenizer.encode(input_text, return_tensors=pt)\\noutputs = model.generate(input_ids, max_length=32, num_beams=1)\\nsentence = tokenizer.decode(outputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)\\nassert sentence == I am a medical doctor.\', \'performance\': {\'dataset\': \'tatoeba\', \'accuracy\': \'Not specified\'}, \'description\': \'Sentence doctor is a T5 model that attempts to correct the errors or mistakes found in sentences. Model works on English, German and French text.\'}', metadata={})]


 Our company specializes in providing information on similar topics. We want to find similar sentences in a text document.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Transformers\', \'functionality\': \'Summarization\', \'api_name\': \'pszemraj/long-t5-tglobal-base-16384-book-summary\', \'api_call\': "T5ForConditionalGeneration.from_pretrained(\'pszemraj/long-t5-tglobal-base-16384-book-summary\')", \'api_arguments\': [\'long_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import pipeline\\nimport torch\\nsummarizer = pipeline(\\n summarization,\\n pszemraj/long-t5-tglobal-base-16384-book-summary,\\n device=0 if torch.cuda.is_available() else -1,\\n)\\nlong_text = Here is a lot of text I don\'t want to read. Replace me\\nresult = summarizer(long_text)\\nprint(result[0][summary_text])", \'performance\': {\'dataset\': \'kmfoda/booksum\', \'accuracy\': {\'ROUGE-1\': 36.408, \'ROUGE-2\': 6.065, \'ROUGE-L\': 16.721, \'ROUGE-LSUM\': 33.34}}, \'description\': \'A fine-tuned version of google/long-t5-tglobal-base on the kmfoda/booksum dataset, which can be used to summarize long text and generate SparkNotes-esque summaries of arbitrary topics. The model generalizes reasonably well to academic and narrative text.\'}', metadata={})]


 The company is building an AI chatbot, and we need a way to process users' questions and tell if two questions are similar.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Automatic Speech Recognition\', \'framework\': \'pyannote.audio\', \'functionality\': \'overlapped-speech-detection\', \'api_name\': \'pyannote/overlapped-speech-detection\', \'api_call\': "pipeline.from_pretrained(\'pyannote/overlapped-speech-detection\', use_auth_token=\'ACCESS_TOKEN_GOES_HERE\')", \'api_arguments\': [\'audio.wav\'], \'python_environment_requirements\': [\'pyannote.audio 2.1\'], \'example_code\': \'from pyannote.audio import Pipeline\\npipeline = Pipeline.from_pretrained(pyannote/overlapped-speech-detection, use_auth_token=ACCESS_TOKEN_GOES_HERE)\\noutput = pipeline(audio.wav)\\nfor speech in output.get_timeline().support():\\n  # two or more speakers are active between speech.start and speech.end\\n  ...\', \'performance\': {\'dataset\': \'ami\', \'accuracy\': None}, \'description\': \'Automatic overlapped speech detection using pyannote.audio framework. The model detects when two or more speakers are active in an audio file.\'}', metadata={})]


 I am a CEO, and I want to create an audio announcement that will be played to my customers. The text announcement is: \"Dear valued customers, we are glad to announce a 30% discount on our special offer. Hurry up!\"\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Transformers\', \'functionality\': \'Sentence Correction\', \'api_name\': \'flexudy/t5-base-multi-sentence-doctor\', \'api_call\': "AutoModelWithLMHead.from_pretrained(\'flexudy/t5-base-multi-sentence-doctor\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'from transformers import AutoTokenizer, AutoModelWithLMHead\\ntokenizer = AutoTokenizer.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\nmodel = AutoModelWithLMHead.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\ninput_text = repair_sentence: m a medical doct context: {That is my job I a}{or I save lives} </s>\\ninput_ids = tokenizer.encode(input_text, return_tensors=pt)\\noutputs = model.generate(input_ids, max_length=32, num_beams=1)\\nsentence = tokenizer.decode(outputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)\\nassert sentence == I am a medical doctor.\', \'performance\': {\'dataset\': \'tatoeba\', \'accuracy\': \'Not specified\'}, \'description\': \'Sentence doctor is a T5 model that attempts to correct the errors or mistakes found in sentences. Model works on English, German and French text.\'}', metadata={})]


 Our user would like to develop an audiobook using a Text-to-Speech API. Convert the text of a book into an audio file.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Question Answering\', \'framework\': \'Transformers\', \'functionality\': \'Question Answering\', \'api_name\': \'distilbert-base-uncased-distilled-squad\', \'api_call\': "pipeline(\'question-answering\', model=\'distilbert-base-uncased-distilled-squad\')", \'api_arguments\': [\'question\', \'context\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import pipeline\\nquestion_answerer = pipeline(question-answering, model=\'distilbert-base-uncased-distilled-squad\')\\ncontext = r\\n... Extractive Question Answering is the task of extracting an answer from a text given a question. An example of a\\n... question answering dataset is the SQuAD dataset, which is entirely based on that task. If you would like to fine-tune\\n... a model on a SQuAD task, you may leverage the examples/pytorch/question-answering/run_squad.py script.\\n... \\nresult = question_answerer(question=What is a good example of a question answering dataset?, context=context)\\nprint(\\n... fAnswer: \'{result[\'answer\']}\', score: {round(result[\'score\'], 4)}, start: {result[\'start\']}, end: {result[\'end\']}\\n...)", \'performance\': {\'dataset\': \'SQuAD v1.1\', \'accuracy\': \'86.9 F1 score\'}, \'description\': "DistilBERT base uncased distilled SQuAD is a fine-tuned version of DistilBERT-base-uncased for the task of question answering. It has 40% less parameters than bert-base-uncased, runs 60% faster while preserving over 95% of BERT\'s performances as measured on the GLUE language understanding benchmark."}', metadata={})]


 In our language app, we want to include text to speech functionality for Hokkien, a dialect of Chinese, using the TAT-TTS dataset.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Feature Extraction\', \'api_name\': \'sberbank-ai/sbert_large_mt_nlu_ru\', \'api_call\': "AutoModel.from_pretrained(\'sberbank-ai/sbert_large_mt_nlu_ru\')", \'api_arguments\': [\'sentences\', \'padding\', \'truncation\', \'max_length\', \'return_tensors\'], \'python_environment_requirements\': [\'transformers\', \'torch\'], \'example_code\': "from transformers import AutoTokenizer, AutoModel\\nimport torch\\n\\n\\n# Mean Pooling - Take attention mask into account for correct averaging\\ndef mean_pooling(model_output, attention_mask):\\n    token_embeddings = model_output[0]  # First element of model_output contains all token embeddings\\n    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()\\n    sum_embeddings = torch.sum(token_embeddings * input_mask_expanded, 1)\\n    sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)\\n    return sum_embeddings / sum_mask\\n\\n\\n# Sentences we want sentence embeddings for sentences = [\'?\']\\n\\n# Load AutoModel from huggingface model repository\\ntokenizer = AutoTokenizer.from_pretrained(sberbank-ai/sbert_large_mt_nlu_ru)\\nmodel = AutoModel.from_pretrained(sberbank-ai/sbert_large_mt_nlu_ru)\\n\\n# Tokenize sentences\\nencoded_input = tokenizer(sentences, padding=True, truncation=True, max_length=24, return_tensors=\'pt\')\\n\\n# Compute token embeddings\\nwith torch.no_grad():\\n    model_output = model(**encoded_input)\\n\\n# Perform pooling. In this case, mean pooling\\nsentence_embeddings = mean_pooling(model_output, encoded_input[\'attention_mask\'])", \'performance\': {\'dataset\': \'Russian SuperGLUE\', \'accuracy\': \'Not provided\'}, \'description\': \'BERT large model multitask (cased) for Sentence Embeddings in Russian language.\'}', metadata={})]


 Develop an application to transcribe audio files with punctuation marks for a podcast platform.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Automatic Speech Recognition\', \'framework\': \'pyannote.audio\', \'functionality\': \'Speaker Diarization\', \'api_name\': \'pyannote/speaker-diarization\', \'api_call\': "Pipeline.from_pretrained(\'pyannote/speaker-diarization@2.1\', use_auth_token=\'ACCESS_TOKEN_GOES_HERE\')", \'api_arguments\': {\'num_speakers\': \'int (optional)\', \'min_speakers\': \'int (optional)\', \'max_speakers\': \'int (optional)\'}, \'python_environment_requirements\': \'pyannote.audio 2.1.1\', \'example_code\': [\'from pyannote.audio import Pipeline\', \'pipeline = Pipeline.from_pretrained(pyannote/speaker-diarization@2.1, use_auth_token=ACCESS_TOKEN_GOES_HERE)\', \'diarization = pipeline(audio.wav)\', \'with open(audio.rttm, w) as rttm:\', \'  diarization.write_rttm(rttm)\'], \'performance\': {\'dataset\': \'ami\', \'accuracy\': {\'DER%\': \'18.91\', \'FA%\': \'4.48\', \'Miss%\': \'9.51\', \'Conf%\': \'4.91\'}}, \'description\': \'This API provides an automatic speaker diarization pipeline using the pyannote.audio framework. It can process audio files and output speaker diarization results in RTTM format. The pipeline can also handle cases where the number of speakers is known in advance or when providing lower and/or upper bounds on the number of speakers.\'}', metadata={})]


 Our company has an audio archive of Chinese podcasts, and we want to create transcripts for them.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Feature Extraction\', \'api_name\': \'sberbank-ai/sbert_large_mt_nlu_ru\', \'api_call\': "AutoModel.from_pretrained(\'sberbank-ai/sbert_large_mt_nlu_ru\')", \'api_arguments\': [\'sentences\', \'padding\', \'truncation\', \'max_length\', \'return_tensors\'], \'python_environment_requirements\': [\'transformers\', \'torch\'], \'example_code\': "from transformers import AutoTokenizer, AutoModel\\nimport torch\\n\\n\\n# Mean Pooling - Take attention mask into account for correct averaging\\ndef mean_pooling(model_output, attention_mask):\\n    token_embeddings = model_output[0]  # First element of model_output contains all token embeddings\\n    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()\\n    sum_embeddings = torch.sum(token_embeddings * input_mask_expanded, 1)\\n    sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)\\n    return sum_embeddings / sum_mask\\n\\n\\n# Sentences we want sentence embeddings for sentences = [\'?\']\\n\\n# Load AutoModel from huggingface model repository\\ntokenizer = AutoTokenizer.from_pretrained(sberbank-ai/sbert_large_mt_nlu_ru)\\nmodel = AutoModel.from_pretrained(sberbank-ai/sbert_large_mt_nlu_ru)\\n\\n# Tokenize sentences\\nencoded_input = tokenizer(sentences, padding=True, truncation=True, max_length=24, return_tensors=\'pt\')\\n\\n# Compute token embeddings\\nwith torch.no_grad():\\n    model_output = model(**encoded_input)\\n\\n# Perform pooling. In this case, mean pooling\\nsentence_embeddings = mean_pooling(model_output, encoded_input[\'attention_mask\'])", \'performance\': {\'dataset\': \'Russian SuperGLUE\', \'accuracy\': \'Not provided\'}, \'description\': \'BERT large model multitask (cased) for Sentence Embeddings in Russian language.\'}', metadata={})]


 We are a podcast platform. We have a library of multiple podcasts that are mixed with background noise. We need to enhance the podcast audio quality to improve the user experience on our platform.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'hyunwoongko/blenderbot-9B\', \'api_call\': "pipeline(\'conversational\', model=\'hyunwoongko/blenderbot-9B\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'Input a message to start chatting with hyunwoongko/blenderbot-9B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'Building open-domain chatbots is a challenging area for machine learning research. While prior work has shown that scaling neural models in the number of parameters and the size of the data they are trained on gives improved results, we show that other ingredients are important for a high-performing chatbot. Good conversation requires a number of skills that an expert conversationalist blends in a seamless way: providing engaging talking points and listening to their partners, both asking and answering questions, and displaying knowledge, empathy and personality appropriately, depending on the situation. We show that large scale models can learn these skills when given appropriate training data and choice of generation strategy. We build variants of these recipes with 90M, 2.7B and 9.4B parameter neural models, and make our models and code publicly available. Human evaluations show our best models are superior to existing approaches in multi-turn dialogue in terms of engagingness and humanness measurements. We then discuss the limitations of this work by analyzing failure cases of our models.\'}', metadata={})]


 A podcast producer is looking to improve the quality of their audio files by removing background noise. What can they do?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Automatic Speech Recognition\', \'framework\': \'pyannote.audio\', \'functionality\': \'Speaker Diarization\', \'api_name\': \'pyannote/speaker-diarization\', \'api_call\': "Pipeline.from_pretrained(\'pyannote/speaker-diarization@2.1\', use_auth_token=\'ACCESS_TOKEN_GOES_HERE\')", \'api_arguments\': {\'num_speakers\': \'int (optional)\', \'min_speakers\': \'int (optional)\', \'max_speakers\': \'int (optional)\'}, \'python_environment_requirements\': \'pyannote.audio 2.1.1\', \'example_code\': [\'from pyannote.audio import Pipeline\', \'pipeline = Pipeline.from_pretrained(pyannote/speaker-diarization@2.1, use_auth_token=ACCESS_TOKEN_GOES_HERE)\', \'diarization = pipeline(audio.wav)\', \'with open(audio.rttm, w) as rttm:\', \'  diarization.write_rttm(rttm)\'], \'performance\': {\'dataset\': \'ami\', \'accuracy\': {\'DER%\': \'18.91\', \'FA%\': \'4.48\', \'Miss%\': \'9.51\', \'Conf%\': \'4.91\'}}, \'description\': \'This API provides an automatic speaker diarization pipeline using the pyannote.audio framework. It can process audio files and output speaker diarization results in RTTM format. The pipeline can also handle cases where the number of speakers is known in advance or when providing lower and/or upper bounds on the number of speakers.\'}', metadata={})]


 I work at a call center, and I need to convert a recorded customer call into an audio file with a different voice without changing the content.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Table Question Answering\', \'framework\': \'Transformers\', \'functionality\': \'Table Question Answering\', \'api_name\': \'google/tapas-large-finetuned-wtq\', \'api_call\': "pipeline(\'table-question-answering\', model=\'google/tapas-large-finetuned-wtq\')", \'api_arguments\': {\'model\': \'google/tapas-large-finetuned-wtq\', \'task\': \'table-question-answering\'}, \'python_environment_requirements\': \'transformers\', \'example_code\': "from transformers import pipeline\\n\\nqa_pipeline = pipeline(\'table-question-answering\', model=\'google/tapas-large-finetuned-wtq\')\\n\\nresult = qa_pipeline(table=table, query=query)", \'performance\': {\'dataset\': \'wikitablequestions\', \'accuracy\': 0.5097}, \'description\': \'TAPAS large model fine-tuned on WikiTable Questions (WTQ). This model was pre-trained on MLM and an additional step which the authors call intermediate pre-training, and then fine-tuned in a chain on SQA, WikiSQL and finally WTQ. It uses relative position embeddings (i.e. resetting the position index at every cell of the table).\'}', metadata={})]


 In a customer support system, we have received a recorded audio file from a customer complaining about an issue in Czech language. Translate it to English language preserving the audio format.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Table Question Answering\', \'framework\': \'PyTorch Transformers\', \'functionality\': \'Table Question Answering\', \'api_name\': \'table-question-answering-tapas\', \'api_call\': "pipeline(\'table-question-answering\', model=\'Meena/table-question-answering-tapas\')", \'api_arguments\': [], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'This model can be loaded on the Inference API on-demand.\', \'performance\': {\'dataset\': [{\'name\': \'SQA (Sequential Question Answering by Microsoft)\', \'accuracy\': None}, {\'name\': \'WTQ (Wiki Table Questions by Stanford University)\', \'accuracy\': None}, {\'name\': \'WikiSQL (by Salesforce)\', \'accuracy\': None}]}, \'description\': \'TAPAS, the model learns an inner representation of the English language used in tables and associated texts, which can then be used to extract features useful for downstream tasks such as answering questions about a table, or determining whether a sentence is entailed or refuted by the contents of a table. It is a BERT-based model specifically designed (and pre-trained) for answering questions about tabular data. TAPAS uses relative position embeddings and has 7 token types that encode tabular structure. It is pre-trained on the masked language modeling (MLM) objective on a large dataset comprising millions of tables from English Wikipedia and corresponding texts.\'}', metadata={})]


 We are a podcast editing company aiming at separating speakers from a recorded audio.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Automatic Speech Recognition\', \'framework\': \'pyannote.audio\', \'functionality\': \'overlapped-speech-detection\', \'api_name\': \'pyannote/overlapped-speech-detection\', \'api_call\': "pipeline.from_pretrained(\'pyannote/overlapped-speech-detection\', use_auth_token=\'ACCESS_TOKEN_GOES_HERE\')", \'api_arguments\': [\'audio.wav\'], \'python_environment_requirements\': [\'pyannote.audio 2.1\'], \'example_code\': \'from pyannote.audio import Pipeline\\npipeline = Pipeline.from_pretrained(pyannote/overlapped-speech-detection, use_auth_token=ACCESS_TOKEN_GOES_HERE)\\noutput = pipeline(audio.wav)\\nfor speech in output.get_timeline().support():\\n  # two or more speakers are active between speech.start and speech.end\\n  ...\', \'performance\': {\'dataset\': \'ami\', \'accuracy\': None}, \'description\': \'Automatic overlapped speech detection using pyannote.audio framework. The model detects when two or more speakers are active in an audio file.\'}', metadata={})]


 We are building a virtual assistant which can translate English speech input to Hokkien in real-time.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'hyunwoongko/blenderbot-9B\', \'api_call\': "pipeline(\'conversational\', model=\'hyunwoongko/blenderbot-9B\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'Input a message to start chatting with hyunwoongko/blenderbot-9B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'Building open-domain chatbots is a challenging area for machine learning research. While prior work has shown that scaling neural models in the number of parameters and the size of the data they are trained on gives improved results, we show that other ingredients are important for a high-performing chatbot. Good conversation requires a number of skills that an expert conversationalist blends in a seamless way: providing engaging talking points and listening to their partners, both asking and answering questions, and displaying knowledge, empathy and personality appropriately, depending on the situation. We show that large scale models can learn these skills when given appropriate training data and choice of generation strategy. We build variants of these recipes with 90M, 2.7B and 9.4B parameter neural models, and make our models and code publicly available. Human evaluations show our best models are superior to existing approaches in multi-turn dialogue in terms of engagingness and humanness measurements. We then discuss the limitations of this work by analyzing failure cases of our models.\'}', metadata={})]


 A language service wants to incorporate a speech-to-speech translation feature that assists users in translating Hokkien to English on an audio file.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Audio-to-Audio\', \'framework\': \'Fairseq\', \'functionality\': \'speech-to-speech-translation\', \'api_name\': \'facebook/textless_sm_en_fr\', \'api_call\': "load_model_ensemble_and_task_from_hf_hub(\'facebook/textless_sm_en_fr\')", \'api_arguments\': [\'input_file\'], \'python_environment_requirements\': [\'huggingface_hub\'], \'example_code\': \'\', \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'This model is a speech-to-speech translation model trained by Facebook. It is designed for translating English speech to French speech.\'}', metadata={})]


 Our company is building an interactive platform for children to learn random trivia quickly. We need a model to understand what is being spoken and what category it belongs to.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Image-to-Text\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'promptcap-coco-vqa\', \'api_call\': "PromptCap(\'vqascore/promptcap-coco-vqa\')", \'api_arguments\': {\'prompt\': \'string\', \'image\': \'string\'}, \'python_environment_requirements\': \'pip install promptcap\', \'example_code\': [\'import torch\', \'from promptcap import PromptCap\', \'model = PromptCap(vqascore/promptcap-coco-vqa)\', \'if torch.cuda.is_available():\', \'  model.cuda()\', \'prompt = please describe this image according to the given question: what piece of clothing is this boy putting on?\', \'image = glove_boy.jpeg\', \'print(model.caption(prompt, image))\'], \'performance\': {\'dataset\': {\'coco\': {\'accuracy\': \'150 CIDEr\'}, \'OK-VQA\': {\'accuracy\': \'60.4%\'}, \'A-OKVQA\': {\'accuracy\': \'59.6%\'}}}, \'description\': \'PromptCap is a captioning model that can be controlled by natural language instruction. The instruction may contain a question that the user is interested in. It achieves SOTA performance on COCO captioning (150 CIDEr) and knowledge-based VQA tasks when paired with GPT-3 (60.4% on OK-VQA and 59.6% on A-OKVQA).\'}', metadata={})]


 We are a company that develops voice assistants, and we need to verify a user's voice to authenticate them.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'hyunwoongko/blenderbot-9B\', \'api_call\': "pipeline(\'conversational\', model=\'hyunwoongko/blenderbot-9B\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'Input a message to start chatting with hyunwoongko/blenderbot-9B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'Building open-domain chatbots is a challenging area for machine learning research. While prior work has shown that scaling neural models in the number of parameters and the size of the data they are trained on gives improved results, we show that other ingredients are important for a high-performing chatbot. Good conversation requires a number of skills that an expert conversationalist blends in a seamless way: providing engaging talking points and listening to their partners, both asking and answering questions, and displaying knowledge, empathy and personality appropriately, depending on the situation. We show that large scale models can learn these skills when given appropriate training data and choice of generation strategy. We build variants of these recipes with 90M, 2.7B and 9.4B parameter neural models, and make our models and code publicly available. Human evaluations show our best models are superior to existing approaches in multi-turn dialogue in terms of engagingness and humanness measurements. We then discuss the limitations of this work by analyzing failure cases of our models.\'}', metadata={})]


 We recently launched a customer service hotline, and we want to estimate the demographics of callers.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'hyunwoongko/blenderbot-9B\', \'api_call\': "pipeline(\'conversational\', model=\'hyunwoongko/blenderbot-9B\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'Input a message to start chatting with hyunwoongko/blenderbot-9B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'Building open-domain chatbots is a challenging area for machine learning research. While prior work has shown that scaling neural models in the number of parameters and the size of the data they are trained on gives improved results, we show that other ingredients are important for a high-performing chatbot. Good conversation requires a number of skills that an expert conversationalist blends in a seamless way: providing engaging talking points and listening to their partners, both asking and answering questions, and displaying knowledge, empathy and personality appropriately, depending on the situation. We show that large scale models can learn these skills when given appropriate training data and choice of generation strategy. We build variants of these recipes with 90M, 2.7B and 9.4B parameter neural models, and make our models and code publicly available. Human evaluations show our best models are superior to existing approaches in multi-turn dialogue in terms of engagingness and humanness measurements. We then discuss the limitations of this work by analyzing failure cases of our models.\'}', metadata={})]


 Create a smart speaker that can recognize voice commands such as \"Turn on the lights,\" \"Play music,\" or \"Set a timer.\"\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Text-to-Speech\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Text-to-Speech\', \'api_name\': \'microsoft/speecht5_tts\', \'api_call\': "SpeechT5ForTextToSpeech.from_pretrained(\'microsoft/speecht5_tts\')", \'api_arguments\': [\'text\', \'return_tensors\', \'input_ids\', \'speaker_embeddings\', \'vocoder\'], \'python_environment_requirements\': \'!pip install git+https://github.com/huggingface/transformers sentencepiece datasets\', \'example_code\': "from transformers import SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan\\nfrom datasets import load_dataset\\nimport torch\\nimport soundfile as sf\\nprocessor = SpeechT5Processor.from_pretrained(\'microsoft/speecht5_tts\')\\nmodel = SpeechT5ForTextToSpeech.from_pretrained(\'microsoft/speecht5_tts\')\\nvocoder = SpeechT5HifiGan.from_pretrained(\'microsoft/speecht5_hifigan\')\\ninputs = processor(text=\'Hello, my dog is cute\', return_tensors=\'pt\')\\nembeddings_dataset = load_dataset(\'Matthijs/cmu-arctic-xvectors\', split=\'validation\')\\nspeaker_embeddings = torch.tensor(embeddings_dataset[7306][\'xvector\']).unsqueeze(0)\\nspeech = model.generate_speech(inputs[\'input_ids\'], speaker_embeddings, vocoder=vocoder)\\nsf.write(\'speech.wav\', speech.numpy(), samplerate=16000)", \'performance\': {\'dataset\': \'LibriTTS\', \'accuracy\': \'Not specified\'}, \'description\': \'SpeechT5 model fine-tuned for speech synthesis (text-to-speech) on LibriTTS. It is a unified-modal SpeechT5 framework that explores the encoder-decoder pre-training for self-supervised speech/text representation learning. It can be used for a wide variety of spoken language processing tasks, including automatic speech recognition, speech synthesis, speech translation, voice conversion, speech enhancement, and speaker identification.\'}', metadata={})]


 Our company's voice assistant needs to be able to detect voice activity in a conversation.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Voice Activity Detection\', \'framework\': \'pyannote.audio\', \'functionality\': \'Automatic Speech Recognition\', \'api_name\': \'pyannote/voice-activity-detection\', \'api_call\': "Pipeline.from_pretrained(\'pyannote/voice-activity-detection\')", \'api_arguments\': [\'audio.wav\'], \'python_environment_requirements\': [\'pyannote.audio 2.1\'], \'example_code\': \'from pyannote.audio import Pipeline\\npipeline = Pipeline.from_pretrained(pyannote/voice-activity-detection, use_auth_token=ACCESS_TOKEN_GOES_HERE)\\noutput = pipeline(audio.wav)\\nfor speech in output.get_timeline().support():\\n  # active speech between speech.start and speech.end\', \'performance\': {\'dataset\': \'ami\', \'accuracy\': \'Not specified\'}, \'description\': \'A pretrained voice activity detection pipeline that detects active speech in audio files.\'}', metadata={})]


Implement a conference call control program which can recognize if there are any interruptions among the speakers during the meeting.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'ToddGoldfarb/Cadet-Tiny\', \'api_call\': "AutoModelForSeq2SeqLM.from_pretrained(\'ToddGoldfarb/Cadet-Tiny\', low_cpu_mem_usage=True)", \'api_arguments\': {\'pretrained_model\': \'t5-small\', \'model_max_length\': 512}, \'python_environment_requirements\': {\'torch\': \'\', \'transformers\': \'\', \'colorful\': \'\'}, \'example_code\': "import torch\\nfrom transformers import AutoTokenizer, AutoModelForSeq2SeqLM\\nimport colorful as cf\\ncf.use_true_colors()\\ncf.use_style(\'monokai\')\\nclass CadetTinyAgent:\\n def init(self):\\n  print(cf.bold | cf.purple(Waking up Cadet-Tiny...))\\n  self.device = torch.device(cuda if torch.cuda.is_available() else cpu)\\n  self.tokenizer = AutoTokenizer.from_pretrained(t5-small, model_max_length=512)\\n  self.model = AutoModelForSeq2SeqLM.from_pretrained(ToddGoldfarb/Cadet-Tiny, low_cpu_mem_usage=True).to(self.device)\\n  self.conversation_history = \\ndef observe(self, observation):\\n self.conversation_history = self.conversation_history + observation\\n # The number 400 below is just a truncation safety net. It leaves room for 112 input tokens.\\n if len(self.conversation_history) > 400:\\n self.conversation_history = self.conversation_history[112:]\\ndef set_input(self, situation_narrative=, role_instruction=):\\n input_text = dialogue: \\n if situation_narrative != :\\n input_text = input_text + situation_narrative\\n if role_instruction != :\\n input_text = input_text +  <SEP>  + role_instruction\\n input_text = input_text +  <TURN>  + self.conversation_history\\n # Uncomment the line below to see what is fed to the model.\\n # print(input_text)\\n return input_text\\ndef generate(self, situation_narrative, role_instruction, user_response):\\n user_response = user_response +  <TURN> \\n self.observe(user_response)\\n input_text = self.set_input(situation_narrative, role_instruction)\\n inputs = self.tokenizer([input_text], return_tensors=pt).to(self.device)\\n # I encourage you to change the hyperparameters of the model! Start by trying to modify the temperature.\\n outputs = self.model.generate(inputs[input_ids], max_new_tokens=512, temperature=1, top_p=.95,\\n do_sample=True)\\n cadet_response = self.tokenizer.decode(outputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=False)\\n added_turn = cadet_response +  <TURN> \\n self.observe(added_turn)\\n return cadet_response\\ndef reset_history(self):\\n self.conversation_history = []\\ndef run(self):\\n def get_valid_input(prompt, default):\\n  while True:\\n   user_input = input(prompt)\\n   if user_input in [Y, N, y, n]:\\n    return user_input\\n   if user_input == :\\n    return default\\n  while True:\\n   continue_chat = \\n   # MODIFY THESE STRINGS TO YOUR LIKING :)\\n   situation_narrative = Imagine you are Cadet-Tiny talking to ???.\\n   role_instruction = You are Cadet-Tiny, and you are talking to ???.\\n   self.chat(situation_narrative, role_instruction)\\n   continue_chat = get_valid_input(cf.purple(Start a new conversation with new setup? [Y/N]:), Y)\\n   if continue_chat in [N, n]:\\n    break\\n   print(cf.blue(CT: See you!))\\ndef chat(self, situation_narrative, role_instruction):\\n print(cf.green(\\n  Cadet-Tiny is running! Input [RESET] to reset the conversation history and [END] to end the conversation.))\\n while True:\\n  user_input = input(You: )\\n  if user_input == [RESET]:\\n   self.reset_history()\\n   print(cf.green([Conversation history cleared. Chat with Cadet-Tiny!]))\\n   continue\\n  if user_input == [END]:\\n   break\\n  response = self.generate(situation_narrative, role_instruction, user_input)\\n  print(cf.blue(CT:  + response))\\ndef main():\\n print(cf.bold | cf.blue(LOADING MODEL))\\nCadetTiny = CadetTinyAgent()\\nCadetTiny.run()\\nif name == \'main\':\\n main()", \'performance\': {\'dataset\': \'allenai/soda\', \'accuracy\': \'\'}, \'description\': \'Cadet-Tiny is a very small conversational model trained off of the SODA dataset. Cadet-Tiny is intended for inference at the edge (on something as small as a 2GB RAM Raspberry Pi). Cadet-Tiny is trained off of the t5-small pretrained model from Google, and is, as a result, is about 2% of the size of the Cosmo-3B model.\'}', metadata={})]


 We are trying to create a solution for an HR department to predict whether a candidate would be a potential employee based on a list of background information.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Video Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Video Classification\', \'api_name\': \'videomae-small-finetuned-ssv2\', \'api_call\': "VideoMAEForVideoClassification.from_pretrained(\'MCG-NJU/videomae-small-finetuned-ssv2\')", \'api_arguments\': {\'model_name\': \'MCG-NJU/videomae-small-finetuned-ssv2\'}, \'python_environment_requirements\': {\'transformers\': \'from transformers import VideoMAEFeatureExtractor, VideoMAEForVideoClassification\', \'numpy\': \'import numpy as np\', \'torch\': \'import torch\'}, \'example_code\': \'video = list(np.random.randn(16, 3, 224, 224))\\nfeature_extractor = VideoMAEFeatureExtractor.from_pretrained(MCG-NJU/videomae-small-finetuned-ssv2)\\nmodel = VideoMAEForVideoClassification.from_pretrained(MCG-NJU/videomae-small-finetuned-ssv2)\\ninputs = feature_extractor(video, return_tensors=pt)\\nwith torch.no_grad():\\n  outputs = model(**inputs)\\n  logits = outputs.logits\\npredicted_class_idx = logits.argmax(-1).item()\\nprint(Predicted class:, model.config.id2label[predicted_class_idx])\', \'performance\': {\'dataset\': \'Something-Something V2\', \'accuracy\': {\'top-1\': 66.8, \'top-5\': 90.3}}, \'description\': \'VideoMAE is an extension of Masked Autoencoders (MAE) to video. The architecture of the model is very similar to that of a standard Vision Transformer (ViT), with a decoder on top for predicting pixel values for masked patches. Videos are presented to the model as a sequence of fixed-size patches (resolution 16x16), which are linearly embedded. One also adds a [CLS] token to the beginning of a sequence to use it for classification tasks. One also adds fixed sinus/cosinus position embeddings before feeding the sequence to the layers of the Transformer encoder. By pre-training the model, it learns an inner representation of videos that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled videos for instance, you can train a standard classifier by placing a linear layer on top of the pre-trained encoder. One typically places a linear layer on top of the [CLS] token, as the last hidden state of this token can be seen as a representation of an entire video.\'}', metadata={})]


 I have just downloaded a dataset that measures CO2 Emissions. I want to classify this dataset using a pre-trained model.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Conversational\', \'api_name\': \'Pi3141/DialoGPT-medium-elon-3\', \'api_call\': "pipeline(\'text-generation\', model=\'Pi3141/DialoGPT-medium-elon-3\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'Input a message to start chatting with Pi3141/DialoGPT-medium-elon-3.\', \'performance\': {\'dataset\': \'Twitter tweets by Elon Musk\', \'accuracy\': \'N/A\'}, \'description\': \'DialoGPT model that talks like Elon Musk, trained on Twitter tweets by Elon Musk. This model will spew meaningless shit about 40% of the time. Trained on 8 epochs. But with a larger dataset this time. The AI can now use more emojis, I think.\'}', metadata={})]


 We are building an app that simulates Pokemon battles. Can you help us predict the HP of a Pokemon given its input attributes?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Regression\', \'framework\': \'Hugging Face\', \'functionality\': \'Predicting Pokemon HP\', \'api_name\': \'julien-c/pokemon-predict-hp\', \'api_call\': "pipeline(\'regression\', model=\'julien-c/pokemon-predict-hp\')", \'api_arguments\': \'input_data\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'julien-c/kaggle-rounakbanik-pokemon\', \'accuracy\': {\'mean_absolute_error\': 15.909, \'model_loss\': 647.605}}, \'description\': \'A tabular regression model trained on the julien-c/kaggle-rounakbanik-pokemon dataset to predict the HP of Pokemon.\'}', metadata={})]


 We are a content marketing agency and we are focusing on promoting our clients' products. We want to use a tool to generate interesting marketing messages.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'hyunwoongko/blenderbot-9B\', \'api_call\': "pipeline(\'conversational\', model=\'hyunwoongko/blenderbot-9B\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'Input a message to start chatting with hyunwoongko/blenderbot-9B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'Building open-domain chatbots is a challenging area for machine learning research. While prior work has shown that scaling neural models in the number of parameters and the size of the data they are trained on gives improved results, we show that other ingredients are important for a high-performing chatbot. Good conversation requires a number of skills that an expert conversationalist blends in a seamless way: providing engaging talking points and listening to their partners, both asking and answering questions, and displaying knowledge, empathy and personality appropriately, depending on the situation. We show that large scale models can learn these skills when given appropriate training data and choice of generation strategy. We build variants of these recipes with 90M, 2.7B and 9.4B parameter neural models, and make our models and code publicly available. Human evaluations show our best models are superior to existing approaches in multi-turn dialogue in terms of engagingness and humanness measurements. We then discuss the limitations of this work by analyzing failure cases of our models.\'}', metadata={})]


 Analyze a set of sentences to find the most similar pairs.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Video Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Video Classification\', \'api_name\': \'videomae-small-finetuned-ssv2\', \'api_call\': "VideoMAEForVideoClassification.from_pretrained(\'MCG-NJU/videomae-small-finetuned-ssv2\')", \'api_arguments\': {\'model_name\': \'MCG-NJU/videomae-small-finetuned-ssv2\'}, \'python_environment_requirements\': {\'transformers\': \'from transformers import VideoMAEFeatureExtractor, VideoMAEForVideoClassification\', \'numpy\': \'import numpy as np\', \'torch\': \'import torch\'}, \'example_code\': \'video = list(np.random.randn(16, 3, 224, 224))\\nfeature_extractor = VideoMAEFeatureExtractor.from_pretrained(MCG-NJU/videomae-small-finetuned-ssv2)\\nmodel = VideoMAEForVideoClassification.from_pretrained(MCG-NJU/videomae-small-finetuned-ssv2)\\ninputs = feature_extractor(video, return_tensors=pt)\\nwith torch.no_grad():\\n  outputs = model(**inputs)\\n  logits = outputs.logits\\npredicted_class_idx = logits.argmax(-1).item()\\nprint(Predicted class:, model.config.id2label[predicted_class_idx])\', \'performance\': {\'dataset\': \'Something-Something V2\', \'accuracy\': {\'top-1\': 66.8, \'top-5\': 90.3}}, \'description\': \'VideoMAE is an extension of Masked Autoencoders (MAE) to video. The architecture of the model is very similar to that of a standard Vision Transformer (ViT), with a decoder on top for predicting pixel values for masked patches. Videos are presented to the model as a sequence of fixed-size patches (resolution 16x16), which are linearly embedded. One also adds a [CLS] token to the beginning of a sequence to use it for classification tasks. One also adds fixed sinus/cosinus position embeddings before feeding the sequence to the layers of the Transformer encoder. By pre-training the model, it learns an inner representation of videos that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled videos for instance, you can train a standard classifier by placing a linear layer on top of the pre-trained encoder. One typically places a linear layer on top of the [CLS] token, as the last hidden state of this token can be seen as a representation of an entire video.\'}', metadata={})]


 I need a tool to extract code syntax and named entities from a text taken from StackOverflow.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Token Classification\', \'framework\': \'Transformers\', \'functionality\': \'Named Entity Recognition\', \'api_name\': \'dslim/bert-base-NER-uncased\', \'api_call\': "pipeline(\'ner\', model=\'dslim/bert-base-NER-uncased\')", \'api_arguments\': {}, \'python_environment_requirements\': {\'transformers\': \'>=4.0.0\'}, \'example_code\': "nlp(\'My name is John and I live in New York.\')", \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'A pretrained BERT model for Named Entity Recognition (NER) on uncased text. It can be used to extract entities such as person names, locations, and organizations from text.\'}', metadata={})]


 Our video streaming platform wants to categorize thousands of movies into genres. Please help us classify them without any genre labels.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Zero-Shot Image Classification\', \'framework\': \'Hugging Face\', \'functionality\': \'Zero-Shot Image Classification\', \'api_name\': \'laion/CLIP-ViT-g-14-laion2B-s34B-b88K\', \'api_call\': "pipeline(\'zero-shot-image-classification\', model=\'laion/CLIP-ViT-g-14-laion2B-s34B-b88K\')", \'api_arguments\': {\'image\': \'path/to/image/file\', \'class_names\': \'list_of_class_names\'}, \'python_environment_requirements\': {\'huggingface_hub\': \'0.0.17\', \'transformers\': \'4.11.3\', \'torch\': \'1.9.0\', \'torchvision\': \'0.10.0\'}, \'example_code\': None, \'performance\': {\'dataset\': None, \'accuracy\': None}, \'description\': \'A zero-shot image classification model based on OpenCLIP, which can classify images into various categories without requiring any training data for those categories.\'}', metadata={})]


 Can you generate an image of a lighthouse on a foggy island, based on my description?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Summarization\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Text Summarization\', \'api_name\': \'distilbart-cnn-12-6-samsum\', \'api_call\': "pipeline(\'summarization\', model=\'philschmid/distilbart-cnn-12-6-samsum\')", \'api_arguments\': {\'model\': \'philschmid/distilbart-cnn-12-6-samsum\'}, \'python_environment_requirements\': \'transformers\', \'example_code\': "from transformers import pipeline\\nsummarizer = pipeline(summarization, model=philschmid/distilbart-cnn-12-6-samsum)\\nconversation = \'\'\'Jeff: Can I train a 🤗 Transformers model on Amazon SageMaker? \\nPhilipp: Sure you can use the new Hugging Face Deep Learning Container. \\nJeff: ok.\\nJeff: and how can I get started? \\nJeff: where can I find documentation? \\nPhilipp: ok, ok you can find everything here. https://huggingface.co/blog/the-partnership-amazon-sagemaker-and-hugging-face <br />\\n\'\'\'\\nsummarizer(conversation)", \'performance\': {\'dataset\': \'samsum\', \'accuracy\': {\'ROUGE-1\': 41.09, \'ROUGE-2\': 20.746, \'ROUGE-L\': 31.595, \'ROUGE-LSUM\': 38.339}}, \'description\': \'This model is a DistilBART-based text summarization model trained on the SAMsum dataset. It can be used to generate summaries of conversational text.\'}', metadata={})]


 I am an illustrator, I want to create an appealing image based on a text description for commercial purposes.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Transformers\', \'functionality\': \'Sentence Correction\', \'api_name\': \'flexudy/t5-base-multi-sentence-doctor\', \'api_call\': "AutoModelWithLMHead.from_pretrained(\'flexudy/t5-base-multi-sentence-doctor\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'from transformers import AutoTokenizer, AutoModelWithLMHead\\ntokenizer = AutoTokenizer.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\nmodel = AutoModelWithLMHead.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\ninput_text = repair_sentence: m a medical doct context: {That is my job I a}{or I save lives} </s>\\ninput_ids = tokenizer.encode(input_text, return_tensors=pt)\\noutputs = model.generate(input_ids, max_length=32, num_beams=1)\\nsentence = tokenizer.decode(outputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)\\nassert sentence == I am a medical doctor.\', \'performance\': {\'dataset\': \'tatoeba\', \'accuracy\': \'Not specified\'}, \'description\': \'Sentence doctor is a T5 model that attempts to correct the errors or mistakes found in sentences. Model works on English, German and French text.\'}', metadata={})]


 We want to build a Twitter Bot that creates an image based on users' textual requests. Generate an image with an astronaut playing guitar in space using a model.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'hyunwoongko/blenderbot-9B\', \'api_call\': "pipeline(\'conversational\', model=\'hyunwoongko/blenderbot-9B\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'Input a message to start chatting with hyunwoongko/blenderbot-9B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'Building open-domain chatbots is a challenging area for machine learning research. While prior work has shown that scaling neural models in the number of parameters and the size of the data they are trained on gives improved results, we show that other ingredients are important for a high-performing chatbot. Good conversation requires a number of skills that an expert conversationalist blends in a seamless way: providing engaging talking points and listening to their partners, both asking and answering questions, and displaying knowledge, empathy and personality appropriately, depending on the situation. We show that large scale models can learn these skills when given appropriate training data and choice of generation strategy. We build variants of these recipes with 90M, 2.7B and 9.4B parameter neural models, and make our models and code publicly available. Human evaluations show our best models are superior to existing approaches in multi-turn dialogue in terms of engagingness and humanness measurements. We then discuss the limitations of this work by analyzing failure cases of our models.\'}', metadata={})]


 Generate an image of a beautiful fantasy landscape based on the description provided: a peaceful scene in a lush green forest with a crystal-clear river flowing through it, under a blue sky with fluffy white clouds.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Video Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Video Classification\', \'api_name\': \'videomae-small-finetuned-ssv2\', \'api_call\': "VideoMAEForVideoClassification.from_pretrained(\'MCG-NJU/videomae-small-finetuned-ssv2\')", \'api_arguments\': {\'model_name\': \'MCG-NJU/videomae-small-finetuned-ssv2\'}, \'python_environment_requirements\': {\'transformers\': \'from transformers import VideoMAEFeatureExtractor, VideoMAEForVideoClassification\', \'numpy\': \'import numpy as np\', \'torch\': \'import torch\'}, \'example_code\': \'video = list(np.random.randn(16, 3, 224, 224))\\nfeature_extractor = VideoMAEFeatureExtractor.from_pretrained(MCG-NJU/videomae-small-finetuned-ssv2)\\nmodel = VideoMAEForVideoClassification.from_pretrained(MCG-NJU/videomae-small-finetuned-ssv2)\\ninputs = feature_extractor(video, return_tensors=pt)\\nwith torch.no_grad():\\n  outputs = model(**inputs)\\n  logits = outputs.logits\\npredicted_class_idx = logits.argmax(-1).item()\\nprint(Predicted class:, model.config.id2label[predicted_class_idx])\', \'performance\': {\'dataset\': \'Something-Something V2\', \'accuracy\': {\'top-1\': 66.8, \'top-5\': 90.3}}, \'description\': \'VideoMAE is an extension of Masked Autoencoders (MAE) to video. The architecture of the model is very similar to that of a standard Vision Transformer (ViT), with a decoder on top for predicting pixel values for masked patches. Videos are presented to the model as a sequence of fixed-size patches (resolution 16x16), which are linearly embedded. One also adds a [CLS] token to the beginning of a sequence to use it for classification tasks. One also adds fixed sinus/cosinus position embeddings before feeding the sequence to the layers of the Transformer encoder. By pre-training the model, it learns an inner representation of videos that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled videos for instance, you can train a standard classifier by placing a linear layer on top of the pre-trained encoder. One typically places a linear layer on top of the [CLS] token, as the last hidden state of this token can be seen as a representation of an entire video.\'}', metadata={})]


 Tell me a text summary and answer a question from an image.\n###Input: img_url=\"https://example.com/image.jpg\", question=\"What is the main color of the object?\"\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Visual Question Answering\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'ivelin/donut-refexp-combined-v1\', \'api_call\': "pipeline(\'visual-question-answering\', model=\'ivelin/donut-refexp-combined-v1\')", \'api_arguments\': \'image, question\', \'python_environment_requirements\': \'transformers\', \'example_code\': "vqa(image=\'path/to/image.jpg\', question=\'What is the color of the object?\')", \'performance\': {\'dataset\': \'ivelin/donut-refexp-combined-v1\', \'accuracy\': \'N/A\'}, \'description\': \'A visual question answering model that takes an image and a question as input and provides an answer based on the visual content of the image and the context of the question.\'}', metadata={})]


 My boss wants me to extract captions from images of people in different settings.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Information Retrieval\', \'api_name\': \'cross-encoder/ms-marco-TinyBERT-L-2-v2\', \'api_call\': "AutoModelForSequenceClassification.from_pretrained(\'cross-encoder/ms-marco-TinyBERT-L-2-v2\')", \'api_arguments\': {\'tokenizer\': "tokenizer = AutoTokenizer.from_pretrained(\'model_name\')", \'features\': "features = tokenizer([\'How many people live in Berlin?\', \'How many people live in Berlin?\'], [\'Berlin has a population of 3,520,031 registered inhabitants in an area of 891.82 square kilometers.\', \'New York City is famous for the Metropolitan Museum of Art.\'], padding=True, truncation=True, return_tensors=\'pt\')"}, \'python_environment_requirements\': [\'transformers\', \'torch\'], \'example_code\': {\'import\': \'from transformers import AutoTokenizer, AutoModelForSequenceClassification\', \'model\': "model = AutoModelForSequenceClassification.from_pretrained(\'model_name\')", \'tokenizer\': "tokenizer = AutoTokenizer.from_pretrained(\'model_name\')", \'features\': "features = tokenizer([\'How many people live in Berlin?\', \'How many people live in Berlin?\'], [\'Berlin has a population of 3,520,031 registered inhabitants in an area of 891.82 square kilometers.\', \'New York City is famous for the Metropolitan Museum of Art.\'], padding=True, truncation=True, return_tensors=\'pt\')", \'scores\': \'with torch.no_grad():\\n    scores = model(**features).logits\\n    print(scores)\'}, \'performance\': {\'dataset\': \'TREC Deep Learning 2019\', \'accuracy\': \'69.84 (NDCG@10)\'}, \'description\': \'This model was trained on the MS Marco Passage Ranking task. It can be used for Information Retrieval: Given a query, encode the query with all possible passages (e.g. retrieved with ElasticSearch). Then sort the passages in a decreasing order. The training code is available here: SBERT.net Training MS Marco.\'}', metadata={})]


 Create an AI system capable of producing short videos based on text input in Persian and English.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Unconditional Image Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Denoising Diffusion Probabilistic Models (DDPM)\', \'api_name\': \'google/ddpm-ema-bedroom-256\', \'api_call\': "DDPMPipeline.from_pretrained(\'google/ddpm-ema-bedroom-256\')", \'api_arguments\': [\'model_id\'], \'python_environment_requirements\': [\'diffusers\'], \'example_code\': \'!pip install diffusers\\nfrom diffusers import DDPMPipeline, DDIMPipeline, PNDMPipeline\\nmodel_id = google/ddpm-ema-bedroom-256\\nddpm = DDPMPipeline.from_pretrained(model_id)\\nimage = ddpm().images[0]\\nimage.save(ddpm_generated_image.png)\', \'performance\': {\'dataset\': \'CIFAR10\', \'accuracy\': {\'Inception_score\': 9.46, \'FID_score\': 3.17}}, \'description\': \'Denoising Diffusion Probabilistic Models (DDPM) is a class of latent variable models inspired by nonequilibrium thermodynamics, capable of producing high-quality image synthesis results. The model can use discrete noise schedulers such as scheduling_ddpm, scheduling_ddim, and scheduling_pndm for inference. It obtains an Inception score of 9.46 and a state-of-the-art FID score of 3.17 on the unconditional CIFAR10 dataset.\'}', metadata={})]


 I am organizing a virtual party and want to create a short, autogenerated video based on a text description (e.g., \"cats playing with laser pointer\"). Can you accomplish this with a text-to-video generation API?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Video\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-Video Synthesis\', \'api_name\': \'modelscope-damo-text-to-video-synthesis\', \'api_call\': "pipeline(\'text-to-video-synthesis\', model_dir.as_posix())", \'api_arguments\': {\'text\': \'A short text description in English\'}, \'python_environment_requirements\': [\'modelscope==1.4.2\', \'open_clip_torch\', \'pytorch-lightning\'], \'example_code\': "from huggingface_hub import snapshot_download\\nfrom modelscope.pipelines import pipeline\\nfrom modelscope.outputs import OutputKeys\\nimport pathlib\\n\\nmodel_dir = pathlib.Path(\'weights\')\\nsnapshot_download(\'damo-vilab/modelscope-damo-text-to-video-synthesis\',\\n repo_type=\'model\', local_dir=model_dir)\\n\\npipe = pipeline(\'text-to-video-synthesis\', model_dir.as_posix())\\n\\ntest_text = {\\n \'text\': \'A panda eating bamboo on a rock.\',\\n}\\n\\noutput_video_path = pipe(test_text,)[OutputKeys.OUTPUT_VIDEO]\\nprint(\'output_video_path:\', output_video_path)", \'performance\': {\'dataset\': \'Webvid, ImageNet, LAION5B\', \'accuracy\': \'Not provided\'}, \'description\': \'This model is based on a multi-stage text-to-video generation diffusion model, which inputs a description text and returns a video that matches the text description. Only English input is supported.\'}', metadata={})]


 I need to create a system that can answer questions related to a document provided. The system should use a pre-trained model.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Audio Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Speaker Verification\', \'api_name\': \'speechbrain/spkrec-xvect-voxceleb\', \'api_call\': "EncoderClassifier.from_hparams(source=\'speechbrain/spkrec-xvect-voxceleb\', savedir=\'pretrained_models/spkrec-xvect-voxceleb\')", \'api_arguments\': [\'source\', \'savedir\'], \'python_environment_requirements\': [\'pip install speechbrain\'], \'example_code\': "import torchaudio\\nfrom speechbrain.pretrained import EncoderClassifier\\nclassifier = EncoderClassifier.from_hparams(source=speechbrain/spkrec-xvect-voxceleb, savedir=pretrained_models/spkrec-xvect-voxceleb)\\nsignal, fs =torchaudio.load(\'tests/samples/ASR/spk1_snt1.wav\')\\nembeddings = classifier.encode_batch(signal)", \'performance\': {\'dataset\': \'Voxceleb1-test set (Cleaned)\', \'accuracy\': \'EER(%) 3.2\'}, \'description\': \'This repository provides all the necessary tools to extract speaker embeddings with a pretrained TDNN model using SpeechBrain. The system is trained on Voxceleb 1+ Voxceleb2 training data.\'}', metadata={})]


 We are developing a document management system. We want to extract the relevant information from them through OCR text scanning and answering questions.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'hyunwoongko/blenderbot-9B\', \'api_call\': "pipeline(\'conversational\', model=\'hyunwoongko/blenderbot-9B\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'Input a message to start chatting with hyunwoongko/blenderbot-9B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'Building open-domain chatbots is a challenging area for machine learning research. While prior work has shown that scaling neural models in the number of parameters and the size of the data they are trained on gives improved results, we show that other ingredients are important for a high-performing chatbot. Good conversation requires a number of skills that an expert conversationalist blends in a seamless way: providing engaging talking points and listening to their partners, both asking and answering questions, and displaying knowledge, empathy and personality appropriately, depending on the situation. We show that large scale models can learn these skills when given appropriate training data and choice of generation strategy. We build variants of these recipes with 90M, 2.7B and 9.4B parameter neural models, and make our models and code publicly available. Human evaluations show our best models are superior to existing approaches in multi-turn dialogue in terms of engagingness and humanness measurements. We then discuss the limitations of this work by analyzing failure cases of our models.\'}', metadata={})]


 The team is creating a home security system. We are currently looking at understanding the depth of objects in the video stream.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'hyunwoongko/blenderbot-9B\', \'api_call\': "pipeline(\'conversational\', model=\'hyunwoongko/blenderbot-9B\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'Input a message to start chatting with hyunwoongko/blenderbot-9B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'Building open-domain chatbots is a challenging area for machine learning research. While prior work has shown that scaling neural models in the number of parameters and the size of the data they are trained on gives improved results, we show that other ingredients are important for a high-performing chatbot. Good conversation requires a number of skills that an expert conversationalist blends in a seamless way: providing engaging talking points and listening to their partners, both asking and answering questions, and displaying knowledge, empathy and personality appropriately, depending on the situation. We show that large scale models can learn these skills when given appropriate training data and choice of generation strategy. We build variants of these recipes with 90M, 2.7B and 9.4B parameter neural models, and make our models and code publicly available. Human evaluations show our best models are superior to existing approaches in multi-turn dialogue in terms of engagingness and humanness measurements. We then discuss the limitations of this work by analyzing failure cases of our models.\'}', metadata={})]


 I want to know the depth information of an image for a robot navigation project.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Summarization\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'text2text-generation\', \'api_name\': \'tuner007/pegasus_summarizer\', \'api_call\': "PegasusForConditionalGeneration.from_pretrained(\'tuner007/pegasus_summarizer\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'pip install sentencepiece\'], \'example_code\': "context = \\nIndia wicket-keeper batsman Rishabh Pant has said someone from the crowd threw a ball on pacer Mohammed Siraj while he was fielding in the ongoing third Test against England on Wednesday. Pant revealed the incident made India skipper Virat Kohli upset. I think, somebody threw a ball inside, at Siraj, so he [Kohli] was upset, said Pant in a virtual press conference after the close of the first day\'s play.You can say whatever you want to chant, but don\'t throw things at the fielders and all those things. It is not good for cricket, I guess, he added.In the third session of the opening day of the third Test, a section of spectators seemed to have asked Siraj the score of the match to tease the pacer. The India pacer however came with a brilliant reply as he gestured 1-0 (India leading the Test series) towards the crowd.Earlier this month, during the second Test match, there was some bad crowd behaviour on a show as some unruly fans threw champagne corks at India batsman KL Rahul.Kohli also intervened and he was seen gesturing towards the opening batsman to know more about the incident. An over later, the TV visuals showed that many champagne corks were thrown inside the playing field, and the Indian players were visibly left frustrated.Coming back to the game, after bundling out India for 78, openers Rory Burns and Haseeb Hameed ensured that England took the honours on the opening day of the ongoing third Test.At stumps, England\'s score reads 120/0 and the hosts have extended their lead to 42 runs. For the Three Lions, Burns (52) and Hameed (60) are currently unbeaten at the crease.Talking about the pitch on opening day, Pant said, They took the heavy roller, the wicket was much more settled down, and they batted nicely also, he said. But when we batted, the wicket was slightly soft, and they bowled in good areas, but we could have applied [ourselves] much better.Both England batsmen managed to see off the final session and the hosts concluded the opening day with all ten wickets intact, extending the lead to 42.(ANI)\\n\\nget_response(context)", \'performance\': {\'dataset\': \'cnn_dailymail\', \'accuracy\': {\'ROUGE-1\': 36.604, \'ROUGE-2\': 14.64, \'ROUGE-L\': 23.884, \'ROUGE-LSUM\': 32.902, \'loss\': 2.576, \'gen_len\': 76.398}}, \'description\': \'PEGASUS fine-tuned for summarization\'}', metadata={})]


 A start-up is looking to develop a robot for navigation; they require a solution to estimate depth from a single image.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Segmentation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'shi-labs/oneformer_ade20k_swin_tiny\', \'api_call\': "OneFormerForUniversalSegmentation.from_pretrained(\'shi-labs/oneformer_ade20k_swin_tiny\')", \'api_arguments\': {\'images\': \'image\', \'task_inputs\': [\'semantic\', \'instance\', \'panoptic\'], \'return_tensors\': \'pt\'}, \'python_environment_requirements\': [\'transformers\', \'PIL\', \'requests\'], \'example_code\': \'from transformers import OneFormerProcessor, OneFormerForUniversalSegmentation\\nfrom PIL import Image\\nimport requests\\nurl = https://huggingface.co/datasets/shi-labs/oneformer_demo/blob/main/ade20k.jpeg\\nimage = Image.open(requests.get(url, stream=True).raw)\\n\\nprocessor = OneFormerProcessor.from_pretrained(shi-labs/oneformer_ade20k_swin_tiny)\\nmodel = OneFormerForUniversalSegmentation.from_pretrained(shi-labs/oneformer_ade20k_swin_tiny)\\n\\nsemantic_inputs = processor(images=image, task_inputs=[semantic], return_tensors=pt)\\nsemantic_outputs = model(**semantic_inputs)\\n\\npredicted_semantic_map = processor.post_process_semantic_segmentation(outputs, target_sizes=[image.size[::-1]])[0]\\n\\ninstance_inputs = processor(images=image, task_inputs=[instance], return_tensors=pt)\\ninstance_outputs = model(**instance_inputs)\\n\\npredicted_instance_map = processor.post_process_instance_segmentation(outputs, target_sizes=[image.size[::-1]])[0][segmentation]\\n\\npanoptic_inputs = processor(images=image, task_inputs=[panoptic], return_tensors=pt)\\npanoptic_outputs = model(**panoptic_inputs)\\n\\npredicted_semantic_map = processor.post_process_panoptic_segmentation(outputs, target_sizes=[image.size[::-1]])[0][segmentation]\', \'performance\': {\'dataset\': \'ADE20k\', \'accuracy\': \'Not provided\'}, \'description\': \'OneFormer is the first multi-task universal image segmentation framework. It needs to be trained only once with a single universal architecture, a single model, and on a single dataset, to outperform existing specialized models across semantic, instance, and panoptic segmentation tasks. OneFormer uses a task token to condition the model on the task in focus, making the architecture task-guided for training, and task-dynamic for inference, all with a single model.\'}', metadata={})]


We are building a smart security system to determine if a person is an adult\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'ToddGoldfarb/Cadet-Tiny\', \'api_call\': "AutoModelForSeq2SeqLM.from_pretrained(\'ToddGoldfarb/Cadet-Tiny\', low_cpu_mem_usage=True)", \'api_arguments\': {\'pretrained_model\': \'t5-small\', \'model_max_length\': 512}, \'python_environment_requirements\': {\'torch\': \'\', \'transformers\': \'\', \'colorful\': \'\'}, \'example_code\': "import torch\\nfrom transformers import AutoTokenizer, AutoModelForSeq2SeqLM\\nimport colorful as cf\\ncf.use_true_colors()\\ncf.use_style(\'monokai\')\\nclass CadetTinyAgent:\\n def init(self):\\n  print(cf.bold | cf.purple(Waking up Cadet-Tiny...))\\n  self.device = torch.device(cuda if torch.cuda.is_available() else cpu)\\n  self.tokenizer = AutoTokenizer.from_pretrained(t5-small, model_max_length=512)\\n  self.model = AutoModelForSeq2SeqLM.from_pretrained(ToddGoldfarb/Cadet-Tiny, low_cpu_mem_usage=True).to(self.device)\\n  self.conversation_history = \\ndef observe(self, observation):\\n self.conversation_history = self.conversation_history + observation\\n # The number 400 below is just a truncation safety net. It leaves room for 112 input tokens.\\n if len(self.conversation_history) > 400:\\n self.conversation_history = self.conversation_history[112:]\\ndef set_input(self, situation_narrative=, role_instruction=):\\n input_text = dialogue: \\n if situation_narrative != :\\n input_text = input_text + situation_narrative\\n if role_instruction != :\\n input_text = input_text +  <SEP>  + role_instruction\\n input_text = input_text +  <TURN>  + self.conversation_history\\n # Uncomment the line below to see what is fed to the model.\\n # print(input_text)\\n return input_text\\ndef generate(self, situation_narrative, role_instruction, user_response):\\n user_response = user_response +  <TURN> \\n self.observe(user_response)\\n input_text = self.set_input(situation_narrative, role_instruction)\\n inputs = self.tokenizer([input_text], return_tensors=pt).to(self.device)\\n # I encourage you to change the hyperparameters of the model! Start by trying to modify the temperature.\\n outputs = self.model.generate(inputs[input_ids], max_new_tokens=512, temperature=1, top_p=.95,\\n do_sample=True)\\n cadet_response = self.tokenizer.decode(outputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=False)\\n added_turn = cadet_response +  <TURN> \\n self.observe(added_turn)\\n return cadet_response\\ndef reset_history(self):\\n self.conversation_history = []\\ndef run(self):\\n def get_valid_input(prompt, default):\\n  while True:\\n   user_input = input(prompt)\\n   if user_input in [Y, N, y, n]:\\n    return user_input\\n   if user_input == :\\n    return default\\n  while True:\\n   continue_chat = \\n   # MODIFY THESE STRINGS TO YOUR LIKING :)\\n   situation_narrative = Imagine you are Cadet-Tiny talking to ???.\\n   role_instruction = You are Cadet-Tiny, and you are talking to ???.\\n   self.chat(situation_narrative, role_instruction)\\n   continue_chat = get_valid_input(cf.purple(Start a new conversation with new setup? [Y/N]:), Y)\\n   if continue_chat in [N, n]:\\n    break\\n   print(cf.blue(CT: See you!))\\ndef chat(self, situation_narrative, role_instruction):\\n print(cf.green(\\n  Cadet-Tiny is running! Input [RESET] to reset the conversation history and [END] to end the conversation.))\\n while True:\\n  user_input = input(You: )\\n  if user_input == [RESET]:\\n   self.reset_history()\\n   print(cf.green([Conversation history cleared. Chat with Cadet-Tiny!]))\\n   continue\\n  if user_input == [END]:\\n   break\\n  response = self.generate(situation_narrative, role_instruction, user_input)\\n  print(cf.blue(CT:  + response))\\ndef main():\\n print(cf.bold | cf.blue(LOADING MODEL))\\nCadetTiny = CadetTinyAgent()\\nCadetTiny.run()\\nif name == \'main\':\\n main()", \'performance\': {\'dataset\': \'allenai/soda\', \'accuracy\': \'\'}, \'description\': \'Cadet-Tiny is a very small conversational model trained off of the SODA dataset. Cadet-Tiny is intended for inference at the edge (on something as small as a 2GB RAM Raspberry Pi). Cadet-Tiny is trained off of the t5-small pretrained model from Google, and is, as a result, is about 2% of the size of the Cosmo-3B model.\'}', metadata={})]


 Design a program that can help farmers detect diseases in bean crops by analyzing images of the crop leaves.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'hyunwoongko/blenderbot-9B\', \'api_call\': "pipeline(\'conversational\', model=\'hyunwoongko/blenderbot-9B\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'Input a message to start chatting with hyunwoongko/blenderbot-9B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'Building open-domain chatbots is a challenging area for machine learning research. While prior work has shown that scaling neural models in the number of parameters and the size of the data they are trained on gives improved results, we show that other ingredients are important for a high-performing chatbot. Good conversation requires a number of skills that an expert conversationalist blends in a seamless way: providing engaging talking points and listening to their partners, both asking and answering questions, and displaying knowledge, empathy and personality appropriately, depending on the situation. We show that large scale models can learn these skills when given appropriate training data and choice of generation strategy. We build variants of these recipes with 90M, 2.7B and 9.4B parameter neural models, and make our models and code publicly available. Human evaluations show our best models are superior to existing approaches in multi-turn dialogue in terms of engagingness and humanness measurements. We then discuss the limitations of this work by analyzing failure cases of our models.\'}', metadata={})]


 To build an intelligent system to recognize and identify objects in submitted pictures within the household, which includes furniture, electronics and ornaments.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Feature Extraction\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Feature Extraction\', \'api_name\': \'DeepPavlov/rubert-base-cased\', \'api_call\': "AutoModel.from_pretrained(\'DeepPavlov/rubert-base-cased\')", \'api_arguments\': [], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'\', \'performance\': {\'dataset\': \'Russian part of Wikipedia and news data\', \'accuracy\': \'\'}, \'description\': \'RuBERT (Russian, cased, 12‑layer, 768‑hidden, 12‑heads, 180M parameters) was trained on the Russian part of Wikipedia and news data. We used this training data to build a vocabulary of Russian subtokens and took a multilingual version of BERT‑base as an initialization for RuBERT[1].\'}', metadata={})]


 Give me a solution to find out the license plate in the given car images.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Zero-Shot Classification\', \'framework\': \'Transformers\', \'functionality\': \'Cross-Encoder for Natural Language Inference\', \'api_name\': \'cross-encoder/nli-deberta-v3-base\', \'api_call\': "CrossEncoder(\'cross-encoder/nli-deberta-v3-base\')", \'api_arguments\': [\'sentence_pairs\'], \'python_environment_requirements\': [\'sentence_transformers\', \'transformers\'], \'example_code\': "from sentence_transformers import CrossEncoder\\nmodel = CrossEncoder(\'cross-encoder/nli-deberta-v3-base\')\\nscores = model.predict([(\'A man is eating pizza\', \'A man eats something\'), (\'A black race car starts up in front of a crowd of people.\', \'A man is driving down a lonely road.\')])", \'performance\': {\'dataset\': {\'SNLI-test\': \'92.38\', \'MNLI mismatched set\': \'90.04\'}}, \'description\': \'This model is based on microsoft/deberta-v3-base and was trained on the SNLI and MultiNLI datasets. For a given sentence pair, it will output three scores corresponding to the labels: contradiction, entailment, neutral.\'}', metadata={})]


 I want to build a social media app for outdoor enthusiasts, and I need to identify objects related to outdoor activities in images. Come up with a proper API call to identify these objects.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'hyunwoongko/blenderbot-9B\', \'api_call\': "pipeline(\'conversational\', model=\'hyunwoongko/blenderbot-9B\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'Input a message to start chatting with hyunwoongko/blenderbot-9B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'Building open-domain chatbots is a challenging area for machine learning research. While prior work has shown that scaling neural models in the number of parameters and the size of the data they are trained on gives improved results, we show that other ingredients are important for a high-performing chatbot. Good conversation requires a number of skills that an expert conversationalist blends in a seamless way: providing engaging talking points and listening to their partners, both asking and answering questions, and displaying knowledge, empathy and personality appropriately, depending on the situation. We show that large scale models can learn these skills when given appropriate training data and choice of generation strategy. We build variants of these recipes with 90M, 2.7B and 9.4B parameter neural models, and make our models and code publicly available. Human evaluations show our best models are superior to existing approaches in multi-turn dialogue in terms of engagingness and humanness measurements. We then discuss the limitations of this work by analyzing failure cases of our models.\'}', metadata={})]


 I want an AI that can separate objects in an image based on semantic segmentation.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Conversational\', \'api_name\': \'Pi3141/DialoGPT-medium-elon-3\', \'api_call\': "pipeline(\'text-generation\', model=\'Pi3141/DialoGPT-medium-elon-3\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'Input a message to start chatting with Pi3141/DialoGPT-medium-elon-3.\', \'performance\': {\'dataset\': \'Twitter tweets by Elon Musk\', \'accuracy\': \'N/A\'}, \'description\': \'DialoGPT model that talks like Elon Musk, trained on Twitter tweets by Elon Musk. This model will spew meaningless shit about 40% of the time. Trained on 8 epochs. But with a larger dataset this time. The AI can now use more emojis, I think.\'}', metadata={})]


 Our image-processing service has to extract contextual information from images.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image-to-Image\', \'framework\': \'Hugging Face\', \'functionality\': \'Image Variations\', \'api_name\': \'lambdalabs/sd-image-variations-diffusers\', \'api_call\': "StableDiffusionImageVariationPipeline.from_pretrained(\'lambdalabs/sd-image-variations-diffusers\', revision=\'v2.0\')", \'api_arguments\': {\'revision\': \'v2.0\'}, \'python_environment_requirements\': \'Diffusers >=0.8.0\', \'example_code\': \'from diffusers import StableDiffusionImageVariationPipeline\\nfrom PIL import Image\\ndevice = cuda:0\\nsd_pipe = StableDiffusionImageVariationPipeline.from_pretrained(\\n lambdalabs/sd-image-variations-diffusers,\\n revision=v2.0,\\n)\\nsd_pipe = sd_pipe.to(device)\\nim = Image.open(path/to/image.jpg)\\ntform = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Resize(\\n  (224, 224),\\n  interpolation=transforms.InterpolationMode.BICUBIC,\\n  antialias=False,\\n ),\\n transforms.Normalize(\\n  [0.48145466, 0.4578275, 0.40821073],\\n  [0.26862954, 0.26130258, 0.27577711]),\\n])\\ninp = tform(im).to(device).unsqueeze(0)\\nout = sd_pipe(inp, guidance_scale=3)\\nout[images][0].save(result.jpg)\', \'performance\': {\'dataset\': \'ChristophSchuhmann/improved_aesthetics_6plus\', \'accuracy\': \'N/A\'}, \'description\': \'This version of Stable Diffusion has been fine tuned from CompVis/stable-diffusion-v1-4-original to accept CLIP image embedding rather than text embeddings. This allows the creation of image variations similar to DALLE-2 using Stable Diffusion.\'}', metadata={})]


 Our company develops a city planning application. We need to segment streets, buildings, and trees in aerial photographs.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'hyunwoongko/blenderbot-9B\', \'api_call\': "pipeline(\'conversational\', model=\'hyunwoongko/blenderbot-9B\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'Input a message to start chatting with hyunwoongko/blenderbot-9B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'Building open-domain chatbots is a challenging area for machine learning research. While prior work has shown that scaling neural models in the number of parameters and the size of the data they are trained on gives improved results, we show that other ingredients are important for a high-performing chatbot. Good conversation requires a number of skills that an expert conversationalist blends in a seamless way: providing engaging talking points and listening to their partners, both asking and answering questions, and displaying knowledge, empathy and personality appropriately, depending on the situation. We show that large scale models can learn these skills when given appropriate training data and choice of generation strategy. We build variants of these recipes with 90M, 2.7B and 9.4B parameter neural models, and make our models and code publicly available. Human evaluations show our best models are superior to existing approaches in multi-turn dialogue in terms of engagingness and humanness measurements. We then discuss the limitations of this work by analyzing failure cases of our models.\'}', metadata={})]


 We are building a product which can identify birds in the images. Design the model which can help us segment the birds in an image.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Segmentation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Image Segmentation\', \'api_name\': \'keremberke/yolov8m-building-segmentation\', \'api_call\': "YOLO(\'keremberke/yolov8m-building-segmentation\')", \'api_arguments\': {\'image\': \'URL or local path to the image\'}, \'python_environment_requirements\': \'pip install ultralyticsplus==0.0.21\', \'example_code\': "from ultralyticsplus import YOLO, render_result\\nmodel = YOLO(\'keremberke/yolov8m-building-segmentation\')\\nmodel.overrides[\'conf\'] = 0.25\\nmodel.overrides[\'iou\'] = 0.45\\nmodel.overrides[\'agnostic_nms\'] = False\\nmodel.overrides[\'max_det\'] = 1000\\nimage = \'https://github.com/ultralytics/yolov5/raw/master/data/images/zidane.jpg\'\\nresults = model.predict(image)\\nprint(results[0].boxes)\\nprint(results[0].masks)\\nrender = render_result(model=model, image=image, result=results[0])\\nrender.show()", \'performance\': {\'dataset\': \'satellite-building-segmentation\', \'accuracy\': {\'mAP@0.5(box)\': 0.623, \'mAP@0.5(mask)\': 0.613}}, \'description\': \'A YOLOv8 model for building segmentation in satellite images. It can detect and segment buildings in the input images.\'}', metadata={})]


 In this Star Wars movie scene, I want to create a depth estimation for the stormtroopers.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Feature Extraction\', \'api_name\': \'sberbank-ai/sbert_large_mt_nlu_ru\', \'api_call\': "AutoModel.from_pretrained(\'sberbank-ai/sbert_large_mt_nlu_ru\')", \'api_arguments\': [\'sentences\', \'padding\', \'truncation\', \'max_length\', \'return_tensors\'], \'python_environment_requirements\': [\'transformers\', \'torch\'], \'example_code\': "from transformers import AutoTokenizer, AutoModel\\nimport torch\\n\\n\\n# Mean Pooling - Take attention mask into account for correct averaging\\ndef mean_pooling(model_output, attention_mask):\\n    token_embeddings = model_output[0]  # First element of model_output contains all token embeddings\\n    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()\\n    sum_embeddings = torch.sum(token_embeddings * input_mask_expanded, 1)\\n    sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)\\n    return sum_embeddings / sum_mask\\n\\n\\n# Sentences we want sentence embeddings for sentences = [\'?\']\\n\\n# Load AutoModel from huggingface model repository\\ntokenizer = AutoTokenizer.from_pretrained(sberbank-ai/sbert_large_mt_nlu_ru)\\nmodel = AutoModel.from_pretrained(sberbank-ai/sbert_large_mt_nlu_ru)\\n\\n# Tokenize sentences\\nencoded_input = tokenizer(sentences, padding=True, truncation=True, max_length=24, return_tensors=\'pt\')\\n\\n# Compute token embeddings\\nwith torch.no_grad():\\n    model_output = model(**encoded_input)\\n\\n# Perform pooling. In this case, mean pooling\\nsentence_embeddings = mean_pooling(model_output, encoded_input[\'attention_mask\'])", \'performance\': {\'dataset\': \'Russian SuperGLUE\', \'accuracy\': \'Not provided\'}, \'description\': \'BERT large model multitask (cased) for Sentence Embeddings in Russian language.\'}', metadata={})]


 I am a drone maker that is building a navigation module for my drones. I need to sharpen the images captured from the drone in real-time.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Transformers\', \'functionality\': \'Sentence Correction\', \'api_name\': \'flexudy/t5-base-multi-sentence-doctor\', \'api_call\': "AutoModelWithLMHead.from_pretrained(\'flexudy/t5-base-multi-sentence-doctor\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'from transformers import AutoTokenizer, AutoModelWithLMHead\\ntokenizer = AutoTokenizer.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\nmodel = AutoModelWithLMHead.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\ninput_text = repair_sentence: m a medical doct context: {That is my job I a}{or I save lives} </s>\\ninput_ids = tokenizer.encode(input_text, return_tensors=pt)\\noutputs = model.generate(input_ids, max_length=32, num_beams=1)\\nsentence = tokenizer.decode(outputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)\\nassert sentence == I am a medical doctor.\', \'performance\': {\'dataset\': \'tatoeba\', \'accuracy\': \'Not specified\'}, \'description\': \'Sentence doctor is a T5 model that attempts to correct the errors or mistakes found in sentences. Model works on English, German and French text.\'}', metadata={})]