 A company developing an application for transcribing customer service calls requires a model that can understand spoken language.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Audio Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Spoken Language Identification\', \'api_name\': \'TalTechNLP/voxlingua107-epaca-tdnn\', \'api_call\': "EncoderClassifier.from_hparams(source=\'TalTechNLP/voxlingua107-epaca-tdnn\')", \'api_arguments\': [\'signal\'], \'python_environment_requirements\': [\'speechbrain\', \'torchaudio\'], \'example_code\': \'import torchaudio\\nfrom speechbrain.pretrained import EncoderClassifier\\nlanguage_id = EncoderClassifier.from_hparams(source=TalTechNLP/voxlingua107-epaca-tdnn, savedir=tmp)\\nsignal = language_id.load_audio(https://omniglot.com/soundfiles/udhr/udhr_th.mp3)\\nprediction = language_id.classify_batch(signal)\\nprint(prediction)\', \'performance\': {\'dataset\': \'VoxLingua107\', \'accuracy\': \'93%\'}, \'description\': \'This is a spoken language recognition model trained on the VoxLingua107 dataset using SpeechBrain. The model uses the ECAPA-TDNN architecture that has previously been used for speaker recognition. The model can classify a speech utterance according to the language spoken. It covers 107 different languages.\'}', metadata={})]


 We are building an audio assistant. Apply noise suppression to our new voice commands.\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 have an audio recording with overlapping speakers talking. We need to remove the overlaps and make it a clear single speaker recording.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'Kirili4ik/mbart_ruDialogSum\', \'api_call\': "MBartForConditionalGeneration.from_pretrained(\'Kirili4ik/mbart_ruDialogSum\')", \'api_arguments\': {\'model_name\': \'Kirili4ik/mbart_ruDialogSum\'}, \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'from transformers import MBartTokenizer, MBartForConditionalGeneration\\nmodel_name = Kirili4ik/mbart_ruDialogSum\\ntokenizer = AutoTokenizer.from_pretrained(model_name)\\nmodel = MBartForConditionalGeneration.from_pretrained(model_name)\\nmodel.eval()\\narticle_text = ...\\ninput_ids = tokenizer(\\n [article_text],\\n max_length=600,\\n padding=max_length,\\n truncation=True,\\n return_tensors=pt,\\n)[input_ids]\\noutput_ids = model.generate(\\n input_ids=input_ids,\\n top_k=0,\\n num_beams=3,\\n no_repeat_ngram_size=3\\n)[0]\\nsummary = tokenizer.decode(output_ids, skip_special_tokens=True)\\nprint(summary)\', \'performance\': {\'dataset\': [{\'name\': \'SAMSum Corpus (translated to Russian)\', \'accuracy\': {\'Validation ROGUE-1\': 34.5, \'Validation ROGUE-L\': 33, \'Test ROGUE-1\': 31, \'Test ROGUE-L\': 28}}]}, \'description\': \'MBart for Russian summarization fine-tuned for dialogues summarization. This model was firstly fine-tuned by Ilya Gusev on Gazeta dataset. We have fine tuned that model on SamSum dataset translated to Russian using GoogleTranslateAPI. Moreover! We have implemented a ! telegram bot @summarization_bot ! with the inference of this model. Add it to the chat and get summaries instead of dozens spam messages!\'}', metadata={})]


 We have just built an app for hosting podcasts, and we need a speech enhancement model to clean noise from the audio recordings submitted by our users.\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={})]


 My coworker sent me a voice message in Spanish. Translate this audio message to English, so that I can understand it.\n###Input: spanish_voice_message.wav\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 developing a virtual assistant and need to integrate a speech enhancement feature in it.\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 kid's educational toy company is including a voice assistant that recognizes simple voice commands from children. They need an example on how to recognize spoken digits.\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 needs to analyze customer phone call recordings and identify specific numbers mentioned by customers during the call.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Token Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Entity Extraction\', \'api_name\': \'903429548\', \'api_call\': "AutoModelForTokenClassification.from_pretrained(\'ismail-lucifer011/autotrain-company_all-903429548\', use_auth_token=True)", \'api_arguments\': {\'inputs\': \'I love AutoTrain\'}, \'python_environment_requirements\': {\'transformers\': \'AutoModelForTokenClassification, AutoTokenizer\'}, \'example_code\': \'from transformers import AutoModelForTokenClassification, AutoTokenizer\\nmodel = AutoModelForTokenClassification.from_pretrained(ismail-lucifer011/autotrain-company_all-903429548, use_auth_token=True)\\ntokenizer = AutoTokenizer.from_pretrained(ismail-lucifer011/autotrain-company_all-903429548, use_auth_token=True)\\ninputs = tokenizer(I love AutoTrain, return_tensors=pt)\\noutputs = model(**inputs)\', \'performance\': {\'dataset\': \'ismail-lucifer011/autotrain-data-company_all\', \'accuracy\': 0.9979930566588805}, \'description\': \'A token classification model trained using AutoTrain for entity extraction. The model is based on the distilbert architecture and trained on the ismail-lucifer011/autotrain-data-company_all dataset. It can be used to identify and extract company names from text.\'}', metadata={})]


 You are building a virtual global tour guide that can identify languages from the audio of people speaking. Use a model to identify which language is being spoken.\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={})]


 I am working as the head of customer service for a Spanish speaking market. I want to know the sentiment of my customers on their last call with our support agents.\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={})]


I have a recording of a meeting from which I need to extract the parts where people are talking and eliminate the silent parts.\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 a company producing wine. Based on the chemical properties of our wine data, we need to analyze the quality of our products and determine whether they are good or bad.\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={})]


 Our team is working on a podcast app, and we want to automatically generate transcripts with timestamps for each speaker.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Visual Question Answering\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'git-large-textvqa\', \'api_call\': "AutoModelForSeq2SeqLM.from_pretrained(\'microsoft/git-large-textvqa\')", \'api_arguments\': \'image, question\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'For code examples, we refer to the documentation.\', \'performance\': {\'dataset\': \'TextVQA\', \'accuracy\': \'See table 11 in the paper for more details.\'}, \'description\': "GIT (short for GenerativeImage2Text) model, large-sized version, fine-tuned on TextVQA. It was introduced in the paper GIT: A Generative Image-to-text Transformer for Vision and Language by Wang et al. and first released in this repository. The model is trained using \'teacher forcing\' on a lot of (image, text) pairs. The goal for the model is simply to predict the next text token, giving the image tokens and previous text tokens. This allows the model to be used for tasks like: image and video captioning, visual question answering (VQA) on images and videos, and even image classification (by simply conditioning the model on the image and asking it to generate a class for it in text)."}', metadata={})]


 I have a large dataset with both numerical and categorical features related to customer behavior. I want to classify them into different segments for targeted marketing. How do I use a TabTransformer for this task?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Classification\', \'framework\': \'Keras\', \'functionality\': \'Structured data learning with TabTransformer\', \'api_name\': \'keras-io/tab_transformer\', \'api_call\': \'TabTransformer.from_config()\', \'api_arguments\': \'N/A\', \'python_environment_requirements\': \'Hugging Face\', \'example_code\': \'N/A\', \'performance\': {\'dataset\': \'United States Census Income Dataset\', \'accuracy\': \'N/A\'}, \'description\': "This model uses self-attention based Transformers structure followed by multiple feed forward layers to serve supervised and semi-supervised learning tasks on tabular data. The model\'s inputs can contain both numerical and categorical features. Categorical features are encoded into embedding vectors before being fed into a stack of Transformer blocks. The contextual embeddings of the categorical features after the final Transformer layer are concatenated with the input numerical features and fed into a final MLP block. A SoftMax function is applied at the end of the model."}', metadata={})]


Determine if an employee's annual salary meets or exceeds $50000.\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={})]


 Identify whether a newly-setup chemical plant is exceeding carbon emission limits based on a CSV file containing data collected.\n###Input: data.csv\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Fill-Mask\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Masked Language Modeling\', \'api_name\': \'xlm-roberta-base\', \'api_call\': "pipeline(\'fill-mask\', model=\'xlm-roberta-base\')", \'api_arguments\': {\'model\': \'xlm-roberta-base\'}, \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import pipeline\\nunmasker = pipeline(\'fill-mask\', model=\'xlm-roberta-base\')\\nunmasker(Hello I\'m a <mask> model.)", \'performance\': {\'dataset\': \'CommonCrawl\', \'accuracy\': \'N/A\'}, \'description\': \'XLM-RoBERTa is a multilingual version of RoBERTa pre-trained on 2.5TB of filtered CommonCrawl data containing 100 languages. It can be used for masked language modeling and is intended to be fine-tuned on a downstream task.\'}', metadata={})]


 I am working in a bank, I want to estimate the mortgage for a given housing using the housing's features.\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 are building a robot for hopping in a controlled environment. Train it to perform a hop using Decision Transformers.\n**Input:<noinput>**\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 robot for elderly care. The robot should be able to understand what's happening and take appropriate actions based on the elderly's current activities.\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 a source code recommendation engine, we need to extract features from text and code using Transformer models.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Code Understanding and Generation\', \'api_name\': \'Salesforce/codet5-base\', \'api_call\': "T5ForConditionalGeneration.from_pretrained(\'Salesforce/codet5-base\')", \'api_arguments\': [\'text\', \'return_tensors\', \'input_ids\', \'max_length\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import RobertaTokenizer, T5ForConditionalGeneration\\ntokenizer = RobertaTokenizer.from_pretrained(\'Salesforce/codet5-base\')\\nmodel = T5ForConditionalGeneration.from_pretrained(\'Salesforce/codet5-base\')\\ntext = def greet(user): print(f\'hello <extra_id_0>!\')\\ninput_ids = tokenizer(text, return_tensors=pt).input_ids\\ngenerated_ids = model.generate(input_ids, max_length=8)\\nprint(tokenizer.decode(generated_ids[0], skip_special_tokens=True))", \'performance\': {\'dataset\': \'code_search_net\', \'accuracy\': \'Refer to the paper for evaluation results on several downstream benchmarks\'}, \'description\': \'CodeT5 is a unified pre-trained encoder-decoder Transformer model that better leverages the code semantics conveyed from the developer-assigned identifiers. It supports both code understanding and generation tasks and allows for multi-task learning. The model can be used for tasks such as code summarization, code generation, code translation, code refinement, code defect detection, and code clone detection.\'}', metadata={})]


 Our team needs to prepare a feature matrix based on the given source code's programming constructs and comments for data analysis.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Program Synthesis\', \'api_name\': \'Salesforce/codegen-350M-multi\', \'api_call\': "AutoTokenizer.from_pretrained(\'Salesforce/codegen-350M-multi\')", \'api_arguments\': [\'text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'from transformers import AutoTokenizer, AutoModelForCausalLM\\ntokenizer = AutoTokenizer.from_pretrained(Salesforce/codegen-350M-multi)\\nmodel = AutoModelForCausalLM.from_pretrained(Salesforce/codegen-350M-multi)\\ntext = def hello_world():\\ninput_ids = tokenizer(text, return_tensors=pt).input_ids\\ngenerated_ids = model.generate(input_ids, max_length=128)\\nprint(tokenizer.decode(generated_ids[0], skip_special_tokens=True))\', \'performance\': {\'dataset\': \'HumanEval and MTPB\', \'accuracy\': \'Refer to the paper for accuracy details\'}, \'description\': \'CodeGen is a family of autoregressive language models for program synthesis. The checkpoint included in this repository is denoted as CodeGen-Multi 350M, where Multi means the model is initialized with CodeGen-NL 350M and further pre-trained on a dataset of multiple programming languages, and 350M refers to the number of trainable parameters. The model is capable of extracting features from given natural language and programming language texts, and calculating the likelihood of them. It is best at program synthesis, generating executable code given English prompts, and can complete partially-generated code as well.\'}', metadata={})]


 We are developing an interactive story app that would display a picture of each character as mentioned in the story given to our GPT-3 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={})]


 As a landscape architect, I want to generate a description of an image of a park I've designed to use for promotional purposes.\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 to build a solution that generates textual descriptions for images in my database.\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 are a company managing hotel bookings. We need to answer our customer's questions regarding rental rates from our pricing document.\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={})]


 Provide me a pipeline for extracting relevant information from an insurance policy document.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Sentence Similarity\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Sentence Transformers\', \'api_name\': \'flax-sentence-embeddings/all_datasets_v4_MiniLM-L6\', \'api_call\': "SentenceTransformer(\'flax-sentence-embeddings/all_datasets_v4_MiniLM-L6\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'sentence-transformers library\', \'example_code\': "from sentence_transformers import SentenceTransformer\\nmodel = SentenceTransformer(\'flax-sentence-embeddings/all_datasets_v4_MiniLM-L6\')\\ntext = Replace me by any text you\'d like.\\ntext_embbedding = model.encode(text)", \'performance\': {\'dataset\': \'1,097,953,922\', \'accuracy\': \'N/A\'}, \'description\': \'The model is trained on very large sentence level datasets using a self-supervised contrastive learning objective. It is fine-tuned on a 1B sentence pairs dataset, and it aims to capture the semantic information of input sentences. The sentence vector can be used for information retrieval, clustering, or sentence similarity tasks.\'}', metadata={})]


 Create an accurate system to estimate the distance between the camera and the objects in a photo captured by a drone flying over a terrain.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Image\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-Image Generation\', \'api_name\': \'stabilityai/stable-diffusion-2-1\', \'api_call\': "StableDiffusionPipeline.from_pretrained(\'stabilityai/stable-diffusion-2-1\', torch_dtype=torch.float16)", \'api_arguments\': {\'prompt\': \'a photo of an astronaut riding a horse on mars\'}, \'python_environment_requirements\': [\'diffusers\', \'transformers\', \'accelerate\', \'scipy\', \'safetensors\'], \'example_code\': \'from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler\\nmodel_id = stabilityai/stable-diffusion-2-1\\npipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)\\npipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)\\npipe = pipe.to(cuda)\\nprompt = a photo of an astronaut riding a horse on mars\\nimage = pipe(prompt).images[0]\\nimage.save(astronaut_rides_horse.png)\', \'performance\': {\'dataset\': \'COCO2017\', \'accuracy\': \'Not optimized for FID scores\'}, \'description\': \'Stable Diffusion v2-1 is a diffusion-based text-to-image generation model developed by Robin Rombach and Patrick Esser. It is capable of generating and modifying images based on text prompts in English. The model is trained on a subset of the LAION-5B dataset and is primarily intended for research purposes.\'}', metadata={})]


 We are a team of architects and civil engineers looking to estimate the depth of elements in architectural designs from 2D images of the structures. We want to implement a depth estimation model that will transform these images into depictions of depth.\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 have an image on my computer named \"eye.jpg\". I want to use a model to predict whether this image indicates diabetic retinopathy.\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 need to build a model that recognizes objects in images. Build a model using the Vision Transformer (ViT) for this purpose.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Feature Extraction\', \'api_name\': \'facebook/dino-vitb16\', \'api_call\': "ViTModel.from_pretrained(\'facebook/dino-vitb16\')", \'api_arguments\': {\'pretrained_model_name_or_path\': \'facebook/dino-vitb16\'}, \'python_environment_requirements\': {\'transformers\': \'latest\', \'PIL\': \'latest\', \'requests\': \'latest\'}, \'example_code\': "from transformers import ViTFeatureExtractor, ViTModel\\nfrom PIL import Image\\nimport requests\\nurl = \'http://images.cocodataset.org/val2017/000000039769.jpg\'\\nimage = Image.open(requests.get(url, stream=True).raw)\\nfeature_extractor = ViTFeatureExtractor.from_pretrained(\'facebook/dino-vitb16\')\\nmodel = ViTModel.from_pretrained(\'facebook/dino-vitb16\')\\ninputs = feature_extractor(images=image, return_tensors=pt)\\noutputs = model(**inputs)\\nlast_hidden_states = outputs.last_hidden_state", \'performance\': {\'dataset\': \'imagenet-1k\', \'accuracy\': \'Not provided\'}, \'description\': \'Vision Transformer (ViT) model trained using the DINO method. The model is pretrained on a large collection of images in a self-supervised fashion, namely ImageNet-1k, at a resolution of 224x224 pixels. Images 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 absolute position embeddings before feeding the sequence to the layers of the Transformer encoder. Note that this model does not include any fine-tuned heads.\'}', metadata={})]


 My pet store website needs a tool to recognize different dog breeds from user uploaded images.\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\', \'api_call\': "AutoModelForTokenClassification.from_pretrained(\'dslim/bert-base-NER\')", \'api_arguments\': {\'model\': \'AutoModelForTokenClassification.from_pretrained(dslim/bert-base-NER)\', \'tokenizer\': \'AutoTokenizer.from_pretrained(dslim/bert-base-NER)\'}, \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'from transformers import AutoTokenizer, AutoModelForTokenClassification\\nfrom transformers import pipeline\\ntokenizer = AutoTokenizer.from_pretrained(dslim/bert-base-NER)\\nmodel = AutoModelForTokenClassification.from_pretrained(dslim/bert-base-NER)\\nnlp = pipeline(ner, model=model, tokenizer=tokenizer)\\nexample = My name is Wolfgang and I live in Berlin\\nner_results = nlp(example)\\nprint(ner_results)\', \'performance\': {\'dataset\': \'conll2003\', \'accuracy\': {\'f1\': 91.3, \'precision\': 90.7, \'recall\': 91.9}}, \'description\': \'bert-base-NER is a fine-tuned BERT model that is ready to use for Named Entity Recognition and achieves state-of-the-art performance for the NER task. It has been trained to recognize four types of entities: location (LOC), organizations (ORG), person (PER) and Miscellaneous (MISC). Specifically, this model is a bert-base-cased model that was fine-tuned on the English version of the standard CoNLL-2003 Named Entity Recognition dataset.\'}', metadata={})]


As a programmer, I want to classify different animal species based on their images. Help me determine the type of species. \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 a robotics company specializing in object detection for logistics. We need to detect objects in warehouses using an advanced object detection model.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Object Detection\', \'framework\': \'Transformers\', \'functionality\': \'Object Detection\', \'api_name\': \'fcakyon/yolov5s-v7.0\', \'api_call\': "yolov5.load(\'fcakyon/yolov5s-v7.0\')", \'api_arguments\': {\'conf\': 0.25, \'iou\': 0.45, \'agnostic\': False, \'multi_label\': False, \'max_det\': 1000, \'img\': \'https://github.com/ultralytics/yolov5/raw/master/data/images/zidane.jpg\', \'size\': 640, \'augment\': True}, \'python_environment_requirements\': \'pip install -U yolov5\', \'example_code\': "import yolov5\\nmodel = yolov5.load(\'fcakyon/yolov5s-v7.0\')\\nmodel.conf = 0.25\\nmodel.iou = 0.45\\nmodel.agnostic = False\\nmodel.multi_label = False\\nmodel.max_det = 1000\\nimg = \'https://github.com/ultralytics/yolov5/raw/master/data/images/zidane.jpg\'\\nresults = model(img)\\nresults = model(img, size=640)\\nresults = model(img, augment=True)\\npredictions = results.pred[0]\\nboxes = predictions[:, :4]\\nscores = predictions[:, 4]\\ncategories = predictions[:, 5]\\nresults.show()\\nresults.save(save_dir=\'results/\')", \'performance\': {\'dataset\': \'detection-datasets/coco\', \'accuracy\': None}, \'description\': \'Yolov5s-v7.0 is an object detection model trained on the COCO dataset. It can detect objects in images and return their bounding boxes, scores, and categories.\'}', metadata={})]


 An IoT device collects images from different locations. Create a model to detect objects in these images to analyze the surroundings.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Object Detection\', \'framework\': \'Transformers\', \'functionality\': \'Object Detection\', \'api_name\': \'fcakyon/yolov5s-v7.0\', \'api_call\': "yolov5.load(\'fcakyon/yolov5s-v7.0\')", \'api_arguments\': {\'conf\': 0.25, \'iou\': 0.45, \'agnostic\': False, \'multi_label\': False, \'max_det\': 1000, \'img\': \'https://github.com/ultralytics/yolov5/raw/master/data/images/zidane.jpg\', \'size\': 640, \'augment\': True}, \'python_environment_requirements\': \'pip install -U yolov5\', \'example_code\': "import yolov5\\nmodel = yolov5.load(\'fcakyon/yolov5s-v7.0\')\\nmodel.conf = 0.25\\nmodel.iou = 0.45\\nmodel.agnostic = False\\nmodel.multi_label = False\\nmodel.max_det = 1000\\nimg = \'https://github.com/ultralytics/yolov5/raw/master/data/images/zidane.jpg\'\\nresults = model(img)\\nresults = model(img, size=640)\\nresults = model(img, augment=True)\\npredictions = results.pred[0]\\nboxes = predictions[:, :4]\\nscores = predictions[:, 4]\\ncategories = predictions[:, 5]\\nresults.show()\\nresults.save(save_dir=\'results/\')", \'performance\': {\'dataset\': \'detection-datasets/coco\', \'accuracy\': None}, \'description\': \'Yolov5s-v7.0 is an object detection model trained on the COCO dataset. It can detect objects in images and return their bounding boxes, scores, and categories.\'}', metadata={})]


 I'm building a drone surveillance system for detecting airplanes in the sky. What can I use to achieve the required object detection?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Automatic Speech Recognition\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'jbetker/wav2vec2-large-robust-ft-libritts-voxpopuli\', \'api_call\': "Wav2Vec2ForCTC.from_pretrained(\'jbetker/wav2vec2-large-robust-ft-libritts-voxpopuli\')", \'api_arguments\': \'\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'https://github.com/neonbjb/ocotillo\', \'performance\': {\'dataset\': \'librispeech validation set\', \'accuracy\': \'4.45%\'}, \'description\': \'This checkpoint is a wav2vec2-large model that is useful for generating transcriptions with punctuation. It is intended for use in building transcriptions for TTS models, where punctuation is very important for prosody. This model was created by fine-tuning the facebook/wav2vec2-large-robust-ft-libri-960h checkpoint on the libritts and voxpopuli datasets with a new vocabulary that includes punctuation.\'}', metadata={})]


We are building an IoT device to monitor apartment corridors for security. Please detect objects in the image and notify if anything abnormal is detected.\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 an application for a smart drone that can detect and segment objects within the area it's flying.\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={})]


 I want to build a tool to recognize urban landscapes and identify different objects in the image.\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-large-NER\', \'api_call\': "AutoModelForTokenClassification.from_pretrained(\'dslim/bert-large-NER\')", \'api_arguments\': {\'model\': "AutoModelForTokenClassification.from_pretrained(\'dslim/bert-large-NER\')", \'tokenizer\': "AutoTokenizer.from_pretrained(\'dslim/bert-large-NER\')"}, \'python_environment_requirements\': {\'transformers\': \'4.0.1\'}, \'example_code\': {\'example\': \'My name is Wolfgang and I live in Berlin\', \'ner_results\': \'nlp(example)\'}, \'performance\': {\'dataset\': \'conll2003\', \'accuracy\': {\'f1\': 0.92, \'precision\': 0.92, \'recall\': 0.919}}, \'description\': \'bert-large-NER is a fine-tuned BERT model that is ready to use for Named Entity Recognition and achieves state-of-the-art performance for the NER task. It has been trained to recognize four types of entities: location (LOC), organizations (ORG), person (PER) and Miscellaneous (MISC).\'}', metadata={})]


 Show me how to detect defects of PCB boards from an image in real-time.\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/yolov8s-pcb-defect-segmentation\', \'api_call\': "YOLO(\'keremberke/yolov8s-pcb-defect-segmentation\')", \'api_arguments\': {\'image\': \'URL or local path to image\'}, \'python_environment_requirements\': [\'ultralyticsplus==0.0.23\', \'ultralytics==8.0.21\'], \'example_code\': "from ultralyticsplus import YOLO, render_result\\n\\nmodel = YOLO(\'keremberke/yolov8s-pcb-defect-segmentation\')\\nmodel.overrides[\'conf\'] = 0.25\\nmodel.overrides[\'iou\'] = 0.45\\nmodel.overrides[\'agnostic_nms\'] = False\\nmodel.overrides[\'max_det\'] = 1000\\n\\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\': \'pcb-defect-segmentation\', \'accuracy\': {\'mAP@0.5(box)\': 0.515, \'mAP@0.5(mask)\': 0.491}}, \'description\': \'YOLOv8s model for PCB defect segmentation. The model is trained to detect and segment PCB defects such as Dry_joint, Incorrect_installation, PCB_damage, and Short_circuit.\'}', metadata={})]


 I want to assess the condition of roads in a city by analyzing drone footage. Create an image segmentation model to identify potholes in images.\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_large\', \'api_call\': "OneFormerForUniversalSegmentation.from_pretrained(\'shi-labs/oneformer_ade20k_swin_large\')", \'api_arguments\': [\'images\', \'task_inputs\', \'return_tensors\'], \'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)\\nprocessor = OneFormerProcessor.from_pretrained(shi-labs/oneformer_ade20k_swin_large)\\nmodel = OneFormerForUniversalSegmentation.from_pretrained(shi-labs/oneformer_ade20k_swin_large)\\nsemantic_inputs = processor(images=image, task_inputs=[semantic], return_tensors=pt)\\nsemantic_outputs = model(**semantic_inputs)\\npredicted_semantic_map = processor.post_process_semantic_segmentation(outputs, target_sizes=[image.size[::-1]])[0]\', \'performance\': {\'dataset\': \'scene_parse_150\', \'accuracy\': None}, \'description\': \'OneFormer model trained on the ADE20k dataset (large-sized version, Swin backbone). It was introduced in the paper OneFormer: One Transformer to Rule Universal Image Segmentation by Jain et al. and first released in this repository. 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 road maintenance reporting application. We need to use images to identify and segment road potholes.\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 marketing team needs different variations of a product image to use in advertising and promotional materials.\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={})]


 A movie studio needs to estimate the human pose of an actor from an image for an upcoming film project.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Text Classification\', \'api_name\': \'lvwerra/distilbert-imdb\', \'api_call\': "pipeline(\'sentiment-analysis\', model=\'lvwerra/distilbert-imdb\')", \'api_arguments\': [], \'python_environment_requirements\': [\'transformers\', \'pytorch\'], \'example_code\': "classifier(\'I love this movie!\')", \'performance\': {\'dataset\': \'imdb\', \'accuracy\': 0.928}, \'description\': \'This model is a fine-tuned version of distilbert-base-uncased on the imdb dataset. It is used for sentiment analysis on movie reviews and achieves an accuracy of 0.928 on the evaluation set.\'}', metadata={})]


 Create a program to determine the depth map from an input image of a street filled with people.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Classification\', \'framework\': \'Keras\', \'functionality\': \'Binary Classification\', \'api_name\': \'TF_Decision_Trees\', \'api_call\': \'TF_Decision_Trees(input_features, target)\', \'api_arguments\': [\'input_features\', \'target\'], \'python_environment_requirements\': [\'tensorflow >= 7.0\'], \'example_code\': \'https://github.com/tdubon/TF-GB-Forest/blob/c0cf4c7e3e29d819b996cfe4eecc1f2728115e52/TFDecisionTrees_Final.ipynb\', \'performance\': {\'dataset\': \'Census-Income Data Set\', \'accuracy\': 96.57}, \'description\': "Use TensorFlow\'s Gradient Boosted Trees model in binary classification of structured data. Build a decision forests model by specifying the input feature usage. Implement a custom Binary Target encoder as a Keras Preprocessing layer to encode the categorical features with respect to their target value co-occurrences, and then use the encoded features to build a decision forests model. The model is trained on the US Census Income Dataset containing approximately 300k instances with 41 numerical and categorical variables. The task is to determine whether a person makes over 50k a year."}', metadata={})]


 I need to create a new piece of art to add to my digital gallery that resembles WikiArt images.\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 team is designing a butterfly-themed stationery set for children. We need to generate images of cute butterflies to use in the design.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Unconditional Image Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Unconditional Image Generation\', \'api_name\': \'ocariz/butterfly_200\', \'api_call\': "DDPMPipeline.from_pretrained(\'ocariz/butterfly_200\')", \'api_arguments\': \'\', \'python_environment_requirements\': \'diffusers\', \'example_code\': "from diffusers import DDPMPipeline\\npipeline = DDPMPipeline.from_pretrained(\'ocariz/butterfly_200\')\\nimage = pipeline().images[0]\\nimage", \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'This model is a diffusion model for unconditional image generation of cute butterflies trained for 200 epochs.\'}', metadata={})]


Design a mobile application that suggests pictures of butterflies whenever the user attempts to change their theme.\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 need to generate some vintage images for a promotion poster.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image-to-Image\', \'framework\': \'Hugging Face\', \'functionality\': \'Image-to-Image\', \'api_name\': \'GreeneryScenery/SheepsControlV3\', \'api_call\': "pipeline(\'image-to-image\', model=\'GreeneryScenery/SheepsControlV3\')", \'api_arguments\': {\'image\': \'Path to image file\', \'text_guidance\': \'Optional text guidance for the model\'}, \'python_environment_requirements\': {\'transformers\': \'latest\', \'torch\': \'latest\'}, \'example_code\': [\'from transformers import pipeline\', "model = pipeline(\'image-to-image\', model=\'GreeneryScenery/SheepsControlV3\')", "result = model({\'image\': \'path/to/image.jpg\', \'text_guidance\': \'Optional text guidance\'})"], \'performance\': {\'dataset\': \'GreeneryScenery/SheepsControlV3\', \'accuracy\': \'Not provided\'}, \'description\': \'GreeneryScenery/SheepsControlV3 is a model for image-to-image tasks. It can be used to generate images based on the input image and optional text guidance. The model has some limitations, such as the conditioning image not affecting the output image much. Improvements can be made by training for more epochs, using better prompts, and preprocessing the data.\'}', metadata={})]


 Generate images of cute butterflies using myunus1/diffmodels_galaxies_scratchbook model.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Unconditional Image Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Unconditional Image Generation\', \'api_name\': \'ocariz/butterfly_200\', \'api_call\': "DDPMPipeline.from_pretrained(\'ocariz/butterfly_200\')", \'api_arguments\': \'\', \'python_environment_requirements\': \'diffusers\', \'example_code\': "from diffusers import DDPMPipeline\\npipeline = DDPMPipeline.from_pretrained(\'ocariz/butterfly_200\')\\nimage = pipeline().images[0]\\nimage", \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'This model is a diffusion model for unconditional image generation of cute butterflies trained for 200 epochs.\'}', metadata={})]


 As part of the online platform's development, we need an AI that, given input text about a video, estimates the content of the video and judges its category.\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={})]


 We need to develop a model to classify sports clips by identifying the type of sports being played in the video.\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={})]