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


 I want to build a system that can answer questions from users reading a book.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Question Answering\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Question Answering\', \'api_name\': \'luhua/chinese_pretrain_mrc_roberta_wwm_ext_large\', \'api_call\': "pipeline(\'question-answering\', model=\'luhua/chinese_pretrain_mrc_roberta_wwm_ext_large\')", \'api_arguments\': \'context, question\', \'python_environment_requirements\': \'transformers\', \'example_code\': "from transformers import pipeline\\nqa_pipeline = pipeline(\'question-answering\', model=\'luhua/chinese_pretrain_mrc_roberta_wwm_ext_large\')\\nresult = qa_pipeline({\'context\': \'your_context_here\', \'question\': \'your_question_here\'})", \'performance\': {\'dataset\': \'Dureader-2021\', \'accuracy\': \'83.1\'}, \'description\': \'A Chinese MRC roberta_wwm_ext_large model trained on a large amount of Chinese MRC data. This model has significantly improved performance on reading comprehension and classification tasks. It has helped multiple users achieve top 5 results in the Dureader-2021 competition.\'}', metadata={})]


Our customer support team needs an AI assistant to handle customer inquiries. It should be able to understand and evaluate if the answer provided by the assistant is contradictory, neutral or entails the customer's question.\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={})]


 Use a zero-shot classifier to classify news headlines into three categories: sports, technology, and politics.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Zero-Shot Classification\', \'framework\': \'Transformers\', \'functionality\': \'Cross-Encoder for Natural Language Inference\', \'api_name\': \'cross-encoder/nli-distilroberta-base\', \'api_call\': "CrossEncoder(\'cross-encoder/nli-distilroberta-base\')", \'api_arguments\': "(\'A man is eating pizza\', \'A man eats something\')", \'python_environment_requirements\': [\'sentence_transformers\', \'transformers\'], \'example_code\': "from transformers import pipeline\\nclassifier = pipeline(zero-shot-classification, model=\'cross-encoder/nli-distilroberta-base\')\\nsent = Apple just announced the newest iPhone X\\ncandidate_labels = [technology, sports, politics]\\nres = classifier(sent, candidate_labels)\\nprint(res)", \'performance\': {\'dataset\': \'SNLI and MultiNLI\', \'accuracy\': \'See SBERT.net - Pretrained Cross-Encoder for evaluation results\'}, \'description\': \'This model was trained using SentenceTransformers Cross-Encoder class on the SNLI and MultiNLI datasets. For a given sentence pair, it will output three scores corresponding to the labels: contradiction, entailment, neutral.\'}', metadata={})]


 Analyze a German text and classify it into different categories like crime, tragedy, or theft.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Zero-Shot Image Classification\', \'framework\': \'Hugging Face\', \'functionality\': \'Zero-Shot Image Classification\', \'api_name\': \'laion/CLIP-ViT-g-14-laion2B-s34B-b88K\', \'api_call\': "pipeline(\'zero-shot-image-classification\', model=\'laion/CLIP-ViT-g-14-laion2B-s34B-b88K\')", \'api_arguments\': {\'image\': \'path/to/image/file\', \'class_names\': \'list_of_class_names\'}, \'python_environment_requirements\': {\'huggingface_hub\': \'0.0.17\', \'transformers\': \'4.11.3\', \'torch\': \'1.9.0\', \'torchvision\': \'0.10.0\'}, \'example_code\': None, \'performance\': {\'dataset\': None, \'accuracy\': None}, \'description\': \'A zero-shot image classification model based on OpenCLIP, which can classify images into various categories without requiring any training data for those categories.\'}', metadata={})]


 Create a tool to determine the logical relationship between two given sentences.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Zero-Shot Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Natural Language Inference\', \'api_name\': \'cointegrated/rubert-base-cased-nli-threeway\', \'api_call\': "AutoModelForSequenceClassification.from_pretrained(\'cointegrated/rubert-base-cased-nli-threeway\')", \'api_arguments\': [\'text1\', \'text2\'], \'python_environment_requirements\': [\'transformers\', \'sentencepiece\'], \'example_code\': "import torch\\nfrom transformers import AutoTokenizer, AutoModelForSequenceClassification\\nmodel_checkpoint = \'cointegrated/rubert-base-cased-nli-threeway\'\\ntokenizer = AutoTokenizer.from_pretrained(model_checkpoint)\\nmodel = AutoModelForSequenceClassification.from_pretrained(model_checkpoint)\\nif torch.cuda.is_available():\\n model.cuda()\\ntext1 = \'.\'\\ntext2 = \'.\'\\nwith torch.inference_mode():\\n out = model(**tokenizer(text1, text2, return_tensors=\'pt\').to(model.device))\\n proba = torch.softmax(out.logits, -1).cpu().numpy()[0]\\nprint({v: proba[k] for k, v in model.config.id2label.items()})", \'performance\': {\'dataset\': [\'JOCI\', \'MNLI\', \'MPE\', \'SICK\', \'SNLI\', \'ANLI\', \'NLI-style FEVER\', \'IMPPRES\'], \'accuracy\': {\'ROC AUC\': {\'entailment\': 0.91, \'contradiction\': 0.71, \'neutral\': 0.79}}}, \'description\': \'This is the DeepPavlov/rubert-base-cased fine-tuned to predict the logical relationship between two short texts: entailment, contradiction, or neutral.\'}', metadata={})]


 A media company needs to summarize a news article in order to make it easy for their audience to understand the main points quickly.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Summarization\', \'framework\': \'Transformers\', \'functionality\': \'text2text-generation\', \'api_name\': \'csebuetnlp/mT5_multilingual_XLSum\', \'api_call\': "AutoModelForSeq2SeqLM.from_pretrained(\'csebuetnlp/mT5_multilingual_XLSum\')", \'api_arguments\': [\'model_name\'], \'python_environment_requirements\': [\'transformers==4.11.0.dev0\'], \'example_code\': "import re\\nfrom transformers import AutoTokenizer, AutoModelForSeq2SeqLM\\nWHITESPACE_HANDLER = lambda k: re.sub(\'\\\\s+\', \' \', re.sub(\'\\\\n+\', \' \', k.strip()))\\narticle_text = Videos that say approved vaccines are dangerous and cause autism, cancer or infertility are among those that will be taken down, the company said. The policy includes the termination of accounts of anti-vaccine influencers. Tech giants have been criticised for not doing more to counter false health information on their sites. In July, US President Joe Biden said social media platforms were largely responsible for people\'s scepticism in getting vaccinated by spreading misinformation, and appealed for them to address the issue. YouTube, which is owned by Google, said 130,000 videos were removed from its platform since last year, when it implemented a ban on content spreading misinformation about Covid vaccines. In a blog post, the company said it had seen false claims about Covid jabs spill over into misinformation about vaccines in general. The new policy covers long-approved vaccines, such as those against measles or hepatitis B. We\'re expanding our medical misinformation policies on YouTube with new guidelines on currently administered vaccines that are approved and confirmed to be safe and effective by local health authorities and the WHO, the post said, referring to the World Health Organization.\\nmodel_name = csebuetnlp/mT5_multilingual_XLSum\\ntokenizer = AutoTokenizer.from_pretrained(model_name)\\nmodel = AutoModelForSeq2SeqLM.from_pretrained(model_name)\\ninput_ids = tokenizer(\\n [WHITESPACE_HANDLER(article_text)],\\n return_tensors=pt,\\n padding=max_length,\\n truncation=True,\\n max_length=512\\n)[input_ids]\\noutput_ids = model.generate(\\n input_ids=input_ids,\\n max_length=84,\\n no_repeat_ngram_size=2,\\n num_beams=4\\n)[0]\\nsummary = tokenizer.decode(\\n output_ids,\\n skip_special_tokens=True,\\n clean_up_tokenization_spaces=False\\n)\\nprint(summary)", \'performance\': {\'dataset\': \'xsum\', \'accuracy\': {\'ROUGE-1\': 36.5, \'ROUGE-2\': 13.934, \'ROUGE-L\': 28.988, \'ROUGE-LSUM\': 28.996, \'loss\': 2.067, \'gen_len\': 26.973}}, \'description\': \'This repository contains the mT5 checkpoint finetuned on the 45 languages of XL-Sum dataset. It is a multilingual abstractive summarization model that supports text-to-text generation for 43 languages.\'}', metadata={})]


 We want to implement a customer service chatbot to engage with website visitors and provide support.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Conversational\', \'api_name\': \'facebook/blenderbot-3B\', \'api_call\': "BlenderbotForConditionalGeneration.from_pretrained(\'facebook/blenderbot-3B\')", \'api_arguments\': [\'model_name\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'Input a message to start chatting with facebook/blenderbot-3B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'BlenderBot-3B is a large-scale neural model designed for open-domain chatbot applications. It is trained on the blended_skill_talk dataset and can engage in multi-turn conversations, providing engaging talking points, asking and answering questions, and displaying knowledge, empathy, and personality. The model is available through the Hugging Face Transformers library.\'}', metadata={})]


 As the project manager of a company who receives long emails, my goal is to summarize them and extract the most important information.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Text2Text Generation\', \'api_name\': \'DialogLED-base-16384\', \'api_call\': "LEDForConditionalGeneration.from_pretrained(\'MingZhong/DialogLED-base-16384\')", \'api_arguments\': \'input_text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'arxiv\', \'accuracy\': \'2109.02492\'}, \'description\': \'DialogLED is a pre-trained model for long dialogue understanding and summarization. It builds on the Longformer-Encoder-Decoder (LED) architecture and uses window-based denoising as the pre-training task on a large amount of long dialogue data for further training. Here is a base version of DialogLED, the input length is limited to 16,384 in the pre-training phase.\'}', metadata={})]


 I am the user and I want to start a multi-turn conversation with this model.\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={})]


 Create a Python function named \"summarize_russian_text\" that accepts a Russian text as input and returns a brief summary of the text.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Video\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-video-synthesis\', \'api_name\': \'damo-vilab/text-to-video-ms-1.7b\', \'api_call\': "DiffusionPipeline.from_pretrained(\'damo-vilab/text-to-video-ms-1.7b\', torch_dtype=torch.float16, variant=fp16)", \'api_arguments\': [\'prompt\', \'num_inference_steps\', \'num_frames\'], \'python_environment_requirements\': [\'pip install git+https://github.com/huggingface/diffusers transformers accelerate\'], \'example_code\': \'pipe = DiffusionPipeline.from_pretrained(damo-vilab/text-to-video-ms-1.7b, torch_dtype=torch.float16, variant=fp16)\\npipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)\\npipe.enable_model_cpu_offload()\\nprompt = Spiderman is surfing\\nvideo_frames = pipe(prompt, num_inference_steps=25).frames\\nvideo_path = export_to_video(video_frames)\', \'performance\': {\'dataset\': \'Webvid\', \'accuracy\': \'Not specified\'}, \'description\': \'A multi-stage text-to-video generation diffusion model that inputs a description text and returns a video that matches the text description. The model consists of three sub-networks: text feature extraction model, text feature-to-video latent space diffusion model, and video latent space to video visual space model. It supports English input only and has a wide range of applications.\'}', metadata={})]


 We want to implement a chatbot on our website to provide quick responses to customer inquiries.\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 want the AI to have an interesting conversation and ask it general knowledge questions.\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 need to create a dialogue in Russian for our educational app. It should cover a general greeting and asking about the users' well-being.\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 company wants to create a chatbot to help answer customer questions regarding the chatbot's consciousness. We need to be able to generate sensible responses.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Transformers\', \'functionality\': \'Conversational\', \'api_name\': \'facebook/blenderbot-400M-distill\', \'api_call\': "BlenderbotForConditionalGeneration.from_pretrained(\'facebook/blenderbot-400M-distill\')", \'api_arguments\': "[\'message\']", \'python_environment_requirements\': [\'transformers\', \'torch\'], \'example_code\': \'Input a message to start chatting with facebook/blenderbot-400M-distill.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not specified\'}, \'description\': \'BlenderBot-400M-distill is a distilled version of the BlenderBot model, trained on the Blended Skill Talk dataset. It is designed for open-domain chatbot tasks and can generate text-to-text responses in a conversational manner. The model is based on the Transformers library and can be used with PyTorch, TensorFlow, and JAX.\'}', metadata={})]


 Create interesting variations of the given phrase 'How can I improve my time management skills?'.\n###Input: How can I improve my time management skills?\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={})]


 A customer wants to convert an input Korean text into a summary. Provide a solution for it.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Text-to-Speech\', \'framework\': \'ESPnet\', \'functionality\': \'Text-to-Speech\', \'api_name\': \'mio/Artoria\', \'api_call\': "pipeline(\'text-to-speech\', model=\'mio/Artoria\')", \'api_arguments\': [\'text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import pipeline; tts = pipeline(\'text-to-speech\', model=\'mio/Artoria\'); tts(\'s\')", \'performance\': {\'dataset\': \'fate\', \'accuracy\': \'Not provided\'}, \'description\': \'This model was trained by mio using fate recipe in espnet. It is a text-to-speech model that can convert text input into speech output.\'}', metadata={})]


 Our company is providing translation services for business clients. We need to translate English contracts to French.\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 an online platform that offers various Chinese language courses for students. Now we need to autoplay a fill-in-the-blank video game for 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={})]


 We want to determine the similarity between two sentences, \"I love going to the park\" and \"My favorite activity is visiting the park\".\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Feature Extraction\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'facebook/dragon-plus-context-encoder\', \'api_call\': "AutoModel.from_pretrained(\'facebook/dragon-plus-context-encoder\')", \'api_arguments\': [\'pretrained\'], \'python_environment_requirements\': [\'torch\', \'transformers\'], \'example_code\': "import torch\\nfrom transformers import AutoTokenizer, AutoModel\\ntokenizer = AutoTokenizer.from_pretrained(\'facebook/dragon-plus-query-encoder\')\\nquery_encoder = AutoModel.from_pretrained(\'facebook/dragon-plus-query-encoder\')\\ncontext_encoder = AutoModel.from_pretrained(\'facebook/dragon-plus-context-encoder\')\\nquery = \'Where was Marie Curie born?\'\\ncontexts = [\\n  \'Maria Sklodowska, later known as Marie Curie, was born on November 7, 1867.\',\\n  \'Born in Paris on 15 May 1859, Pierre Curie was the son of Eugène Curie, a doctor of French Catholic origin from Alsace.\'\\n]\\nquery_input = tokenizer(query, return_tensors=\'pt\')\\nctx_input = tokenizer(contexts, padding=True, truncation=True, return_tensors=\'pt\')\\nquery_emb = query_encoder(query_input).last_hidden_state[:, 0, :]\\nctx_emb = context_encoder(ctx_input).last_hidden_state[:, 0, :]\\nscore1 = query_emb @ ctx_emb[0]\\nscore2 = query_emb @ ctx_emb[1]", \'performance\': {\'dataset\': \'MS MARCO\', \'accuracy\': 39.0}, \'description\': \'DRAGON+ is a BERT-base sized dense retriever initialized from RetroMAE and further trained on the data augmented from MS MARCO corpus, following the approach described in How to Train Your DRAGON: Diverse Augmentation Towards Generalizable Dense Retrieval. The associated GitHub repository is available here https://github.com/facebookresearch/dpr-scale/tree/main/dragon. We use asymmetric dual encoder, with two distinctly parameterized encoders.\'}', metadata={})]


 We have an audiobook app in the Chinese language, and we want to convert the Chinese text to speech.\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 want to build an audiobook service. We need to convert text to speech for the user to listen.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Feature Extraction\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Feature Extraction\', \'api_name\': \'DeepPavlov/rubert-base-cased\', \'api_call\': "AutoModel.from_pretrained(\'DeepPavlov/rubert-base-cased\')", \'api_arguments\': [], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'\', \'performance\': {\'dataset\': \'Russian part of Wikipedia and news data\', \'accuracy\': \'\'}, \'description\': \'RuBERT (Russian, cased, 12‑layer, 768‑hidden, 12‑heads, 180M parameters) was trained on the Russian part of Wikipedia and news data. We used this training data to build a vocabulary of Russian subtokens and took a multilingual version of BERT‑base as an initialization for RuBERT[1].\'}', metadata={})]


 I want to convert English speech into different language speech. I have some audio in English language and I would like to convert that into Spanish.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Text-to-Speech\', \'framework\': \'ESPnet\', \'functionality\': \'Text-to-Speech\', \'api_name\': \'kan-bayashi_csmsc_tts_train_tacotron2_raw_phn_pypinyin_g2p_phone_train.loss.best\', \'api_call\': "Text2Speech.from_pretrained(\'espnet/kan-bayashi_csmsc_tts_train_tacotron2_raw_phn_pypinyin_g2p_phone_train.loss.best\')", \'api_arguments\': [\'text\'], \'python_environment_requirements\': [\'torch\', \'espnet_model_zoo\'], \'example_code\': \'import soundfile\\nfrom espnet2.bin.tts_inference import Text2Speech\\ntext2speech = Text2Speech.from_pretrained(espnet/kan-bayashi_csmsc_tts_train_tacotron2_raw_phn_pypinyin_g2p_phone_train.loss.best)\\ntext = 春江潮水连海平，海上明月共潮生\\nspeech = text2speech(text)[wav]\\nsoundfile.write(out.wav, speech.numpy(), text2speech.fs, PCM_16)\', \'performance\': {\'dataset\': \'csmsc\', \'accuracy\': \'Not specified\'}, \'description\': \'A pre-trained Text-to-Speech model for Chinese language using ESPnet framework. It can be used to convert text input into speech output in Chinese.\'}', metadata={})]


We are trying to transcribe audios. Can you help with giving us an ASR model?\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={})]


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


Create a program to separate music and vocals from an audio file using a pretrained model.\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={})]


 \nCreate an application that automatically separates vocals from a song for karaoke nights.\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={})]


 One of our clients need high recognition capability of denoising audio streams for improving sound quality.\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={})]


A podcast company reached out to us wanting to change their speaker's voice in a recorded podcast.\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={})]


 Our research team is focused on the analysis and separation of complex audio recordings. We need a model to be able to separate speaker voices from mixed sound.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'financial-sentiment-analysis\', \'api_name\': \'yiyanghkust/finbert-tone\', \'api_call\': "BertForSequenceClassification.from_pretrained(\'yiyanghkust/finbert-tone\',num_labels=3)", \'api_arguments\': [\'sentences\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import BertTokenizer, BertForSequenceClassification\\nfrom transformers import pipeline\\nfinbert = BertForSequenceClassification.from_pretrained(\'yiyanghkust/finbert-tone\',num_labels=3)\\ntokenizer = BertTokenizer.from_pretrained(\'yiyanghkust/finbert-tone\')\\nnlp = pipeline(sentiment-analysis, model=finbert, tokenizer=tokenizer)\\nsentences = [there is a shortage of capital, and we need extra financing,\\n growth is strong and we have plenty of liquidity,\\n there are doubts about our finances,\\n profits are flat]\\nresults = nlp(sentences)\\nprint(results)", \'performance\': {\'dataset\': \'10,000 manually annotated sentences from analyst reports\', \'accuracy\': \'superior performance on financial tone analysis task\'}, \'description\': \'FinBERT is a BERT model pre-trained on financial communication text. It is trained on the following three financial communication corpus: Corporate Reports 10-K & 10-Q, Earnings Call Transcripts, and Analyst Reports. This released finbert-tone model is the FinBERT model fine-tuned on 10,000 manually annotated (positive, negative, neutral) sentences from analyst reports. This model achieves superior performance on financial tone analysis task.\'}', metadata={})]


 A Romanian-speaking person wants to communicate with an English-speaking friend over the phone using our platform. Please provide a method to translate their speech in real-time.\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={})]


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


 A toy company wants to use your software to recognize spoken numbers (0-9) in English by young children for an interactive game. Please create an identifier.\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={})]


 Develop an automated podcast recommender system to suggest content that matches user's taste based on their favorite podcast speakers.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Automatic Speech Recognition\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Feature Extraction\', \'api_name\': \'microsoft/wavlm-large\', \'api_call\': "Wav2Vec2Model.from_pretrained(\'microsoft/wavlm-large\')", \'api_arguments\': \'speech input\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'To fine-tune the model for speech recognition, see the official speech recognition example. To fine-tune the model for speech classification, see the official audio classification example.\', \'performance\': {\'dataset\': \'SUPERB benchmark\', \'accuracy\': \'state-of-the-art performance\'}, \'description\': \'WavLM-Large is a large model pretrained on 16kHz sampled speech audio. It is built based on the HuBERT framework, with an emphasis on both spoken content modeling and speaker identity preservation. WavLM is pretrained on 60,000 hours of Libri-Light, 10,000 hours of GigaSpeech, and 24,000 hours of VoxPopuli. It achieves state-of-the-art performance on the SUPERB benchmark and brings significant improvements for various speech processing tasks on their representative benchmarks.\'}', metadata={})]


 We are developing an app that can help mediate virtual therapy sessions. We need a feature that can detect emotions in the voice of the user.\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 engineering a green consulting firm. We need to predict carbon emissions with input features from customer's dataset.\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={})]


Develop a system that can detect voices in a podcast to find out if guests are speaking or not. \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={})]


 Develop a machine learning product to help home buyers predict house prices in the US.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Token Classification\', \'framework\': \'Flair\', \'functionality\': \'Named Entity Recognition\', \'api_name\': \'flair/ner-english-ontonotes-large\', \'api_call\': "SequenceTagger.load(\'flair/ner-english-ontonotes-large\')", \'api_arguments\': [\'sentence\'], \'python_environment_requirements\': [\'flair\'], \'example_code\': "from flair.data import Sentence\\nfrom flair.models import SequenceTagger\\n\\n# load tagger\\ntagger = SequenceTagger.load(\'flair/ner-english-ontonotes-large\')\\n\\n# make example sentence\\nsentence = Sentence(\'On September 1st George won 1 dollar while watching Game of Thrones.\')\\n\\n# predict NER tags\\ntagger.predict(sentence)\\n\\n# print sentence\\nprint(sentence)\\n\\n# print predicted NER spans\\nprint(\'The following NER tags are found:\')\\n\\n# iterate over entities and print\\nfor entity in sentence.get_spans(\'ner\'):\\n    print(entity)", \'performance\': {\'dataset\': \'Ontonotes\', \'accuracy\': 90.93}, \'description\': \'English NER in Flair (Ontonotes large model). This is the large 18-class NER model for English that ships with Flair. It predicts 18 tags such as cardinal value, date value, event name, building name, geo-political entity, language name, law name, location name, money name, affiliation, ordinal value, organization name, percent value, person name, product name, quantity value, time value, and name of work of art. The model is based on document-level XLM-R embeddings and FLERT.\'}', metadata={})]


 A game developer needs to predict the HP of a new Pokemon character based on several attributes. Provide the code to make that prediction.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Regression\', \'framework\': \'Hugging Face\', \'functionality\': \'Predicting Pokemon HP\', \'api_name\': \'julien-c/pokemon-predict-hp\', \'api_call\': "pipeline(\'regression\', model=\'julien-c/pokemon-predict-hp\')", \'api_arguments\': \'input_data\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'julien-c/kaggle-rounakbanik-pokemon\', \'accuracy\': {\'mean_absolute_error\': 15.909, \'model_loss\': 647.605}}, \'description\': \'A tabular regression model trained on the julien-c/kaggle-rounakbanik-pokemon dataset to predict the HP of Pokemon.\'}', metadata={})]


 Let's create a smart agent that can learn to play CartPole-v0 using reinforcement learning.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Reinforcement Learning\', \'framework\': \'ML-Agents\', \'functionality\': \'SoccerTwos\', \'api_name\': \'Raiden-1001/poca-Soccerv7\', \'api_call\': "mlagents-load-from-hf --repo-id=\'Raiden-1001/poca-Soccerv7.1\' --local-dir=\'./downloads\'", \'api_arguments\': [\'your_configuration_file_path.yaml\', \'run_id\'], \'python_environment_requirements\': [\'unity-ml-agents\', \'deep-reinforcement-learning\', \'ML-Agents-SoccerTwos\'], \'example_code\': \'Step 1: Write your model_id: Raiden-1001/poca-Soccerv7\\nStep 2: Select your .nn /.onnx file\\nClick on Watch the agent play 👀\', \'performance\': {\'dataset\': \'SoccerTwos\', \'accuracy\': \'Not provided\'}, \'description\': \'This is a trained model of a poca agent playing SoccerTwos using the Unity ML-Agents Library.\'}', metadata={})]


 The sports equipment company I work for wants to build a virtual soccer training game. The agent must be able to effectively play soccer against another team.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Transformers\', \'functionality\': \'Sentiment Analysis\', \'api_name\': \'michellejieli/NSFW_text_classifier\', \'api_call\': "pipeline(\'sentiment-analysis\', model=\'michellejieli/NSFW_text_classification\')", \'api_arguments\': [\'text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'classifier(I see you’ve set aside this special time to humiliate yourself in public.)\', \'performance\': {\'dataset\': \'Reddit posts\', \'accuracy\': \'Not specified\'}, \'description\': \'DistilBERT is a transformer model that performs sentiment analysis. I fine-tuned the model on Reddit posts with the purpose of classifying not safe for work (NSFW) content, specifically text that is considered inappropriate and unprofessional. The model predicts 2 classes, which are NSFW or safe for work (SFW). The model is a fine-tuned version of DistilBERT. It was fine-tuned on 14317 Reddit posts pulled from the Reddit API.\'}', metadata={})]


 We want to build a smart-cars training system for our team. I need you to solve the gym environment 'MountainCar-v0'.\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 a group of teachers looking to create an automated summary based on the student's essays.\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={})]


 An important project is under development, and we need to know the positional relations between various keywords of a given medical text.\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={})]


 Build a system for detecting hate speech from social media comments in Korean.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Summarization\', \'framework\': \'Transformers\', \'functionality\': \'text2text-generation\', \'api_name\': \'csebuetnlp/mT5_multilingual_XLSum\', \'api_call\': "AutoModelForSeq2SeqLM.from_pretrained(\'csebuetnlp/mT5_multilingual_XLSum\')", \'api_arguments\': [\'model_name\'], \'python_environment_requirements\': [\'transformers==4.11.0.dev0\'], \'example_code\': "import re\\nfrom transformers import AutoTokenizer, AutoModelForSeq2SeqLM\\nWHITESPACE_HANDLER = lambda k: re.sub(\'\\\\s+\', \' \', re.sub(\'\\\\n+\', \' \', k.strip()))\\narticle_text = Videos that say approved vaccines are dangerous and cause autism, cancer or infertility are among those that will be taken down, the company said. The policy includes the termination of accounts of anti-vaccine influencers. Tech giants have been criticised for not doing more to counter false health information on their sites. In July, US President Joe Biden said social media platforms were largely responsible for people\'s scepticism in getting vaccinated by spreading misinformation, and appealed for them to address the issue. YouTube, which is owned by Google, said 130,000 videos were removed from its platform since last year, when it implemented a ban on content spreading misinformation about Covid vaccines. In a blog post, the company said it had seen false claims about Covid jabs spill over into misinformation about vaccines in general. The new policy covers long-approved vaccines, such as those against measles or hepatitis B. We\'re expanding our medical misinformation policies on YouTube with new guidelines on currently administered vaccines that are approved and confirmed to be safe and effective by local health authorities and the WHO, the post said, referring to the World Health Organization.\\nmodel_name = csebuetnlp/mT5_multilingual_XLSum\\ntokenizer = AutoTokenizer.from_pretrained(model_name)\\nmodel = AutoModelForSeq2SeqLM.from_pretrained(model_name)\\ninput_ids = tokenizer(\\n [WHITESPACE_HANDLER(article_text)],\\n return_tensors=pt,\\n padding=max_length,\\n truncation=True,\\n max_length=512\\n)[input_ids]\\noutput_ids = model.generate(\\n input_ids=input_ids,\\n max_length=84,\\n no_repeat_ngram_size=2,\\n num_beams=4\\n)[0]\\nsummary = tokenizer.decode(\\n output_ids,\\n skip_special_tokens=True,\\n clean_up_tokenization_spaces=False\\n)\\nprint(summary)", \'performance\': {\'dataset\': \'xsum\', \'accuracy\': {\'ROUGE-1\': 36.5, \'ROUGE-2\': 13.934, \'ROUGE-L\': 28.988, \'ROUGE-LSUM\': 28.996, \'loss\': 2.067, \'gen_len\': 26.973}}, \'description\': \'This repository contains the mT5 checkpoint finetuned on the 45 languages of XL-Sum dataset. It is a multilingual abstractive summarization model that supports text-to-text generation for 43 languages.\'}', metadata={})]


 Our team is working on a recommendation system for a news article app. We should understand the semantic similarity of various texts.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Feature Extraction\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Feature Extraction\', \'api_name\': \'DeepPavlov/rubert-base-cased\', \'api_call\': "AutoModel.from_pretrained(\'DeepPavlov/rubert-base-cased\')", \'api_arguments\': [], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'\', \'performance\': {\'dataset\': \'Russian part of Wikipedia and news data\', \'accuracy\': \'\'}, \'description\': \'RuBERT (Russian, cased, 12‑layer, 768‑hidden, 12‑heads, 180M parameters) was trained on the Russian part of Wikipedia and news data. We used this training data to build a vocabulary of Russian subtokens and took a multilingual version of BERT‑base as an initialization for RuBERT[1].\'}', metadata={})]


 We are developing an AI chatbot for a Russian company. I want to extract features from the clients' text messages in Russian language.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Feature Extraction\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Feature Extraction\', \'api_name\': \'DeepPavlov/rubert-base-cased\', \'api_call\': "AutoModel.from_pretrained(\'DeepPavlov/rubert-base-cased\')", \'api_arguments\': [], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'\', \'performance\': {\'dataset\': \'Russian part of Wikipedia and news data\', \'accuracy\': \'\'}, \'description\': \'RuBERT (Russian, cased, 12‑layer, 768‑hidden, 12‑heads, 180M parameters) was trained on the Russian part of Wikipedia and news data. We used this training data to build a vocabulary of Russian subtokens and took a multilingual version of BERT‑base as an initialization for RuBERT[1].\'}', metadata={})]


 I am an artist who wants to create a new piece of artwork based on the prompt \"A futuristic city under the ocean\".\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Image\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-Image\', \'api_name\': \'wavymulder/Analog-Diffusion\', \'api_call\': "pipeline(\'text-to-image\', model=\'wavymulder/Analog-Diffusion\')", \'api_arguments\': [\'prompt\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': "text_to_image(\'analog style landscape\')", \'performance\': {\'dataset\': \'analog photographs\', \'accuracy\': \'Not specified\'}, \'description\': "Analog Diffusion is a dreambooth model trained on a diverse set of analog photographs. It can generate images based on text prompts with an analog style. Use the activation token \'analog style\' in your prompt to get the desired output. The model is available on the Hugging Face Inference API and can be used with the transformers library."}', metadata={})]


 Create a character-like artwork image based on the phrase 'anime-style girl with a guitar'.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Paraphrasing\', \'api_name\': \'prithivida/parrot_paraphraser_on_T5\', \'api_call\': "Parrot(model_tag=\'prithivida/parrot_paraphraser_on_T5\', use_gpu=False)", \'api_arguments\': [\'input_phrase\', \'diversity_ranker\', \'do_diverse\', \'max_return_phrases\', \'max_length\', \'adequacy_threshold\', \'fluency_threshold\'], \'python_environment_requirements\': [\'torch\', \'transformers\'], \'example_code\': \'from parrot import Parrot\\nimport torch\\nimport warnings\\nwarnings.filterwarnings(ignore)\\n\\nparrot = Parrot(model_tag=prithivida/parrot_paraphraser_on_T5, use_gpu=False)\\nphrases = [Can you recommed some upscale restaurants in Newyork?,\\n What are the famous places we should not miss in Russia?\\n]\\nfor phrase in phrases:\\n print(-*100)\\n print(Input_phrase: , phrase)\\n print(-*100)\\n para_phrases = parrot.augment(input_phrase=phrase)\\n for para_phrase in para_phrases:\\n  print(para_phrase)\', \'performance\': {\'dataset\': \'Not mentioned\', \'accuracy\': \'Not mentioned\'}, \'description\': \'Parrot is a paraphrase based utterance augmentation framework purpose built to accelerate training NLU models. It offers knobs to control Adequacy, Fluency, and Diversity as per your needs. It mainly focuses on augmenting texts typed-into or spoken-to conversational interfaces for building robust NLU models.\'}', metadata={})]


 We are designing an application that can generate images based on textual descriptions. We need to load a model capable of performing text-to-image conversion.\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 food delivery app wants to help users understand ingredients in the food item by analyzing the images. We need a solution to process the food images and give textual information about the items.\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 company wants to create a social media application like Pinterest that generates captions for users' images. Show us how to create this functionality.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Image\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-Image\', \'api_name\': \'gsdf/Counterfeit-V2.5\', \'api_call\': "pipeline(\'text-to-image\', model=\'gsdf/Counterfeit-V2.5\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'((masterpiece,best quality)),1girl, solo, animal ears, rabbit, barefoot, knees up, dress, sitting, rabbit ears, short sleeves, looking at viewer, grass, short hair, smile, white hair, puffy sleeves, outdoors, puffy short sleeves, bangs, on ground, full body, animal, white dress, sunlight, brown eyes, dappled sunlight, day, depth of field\', \'performance\': {\'dataset\': \'EasyNegative\', \'accuracy\': \'Not provided\'}, \'description\': \'Counterfeit-V2.5 is a text-to-image model that generates anime-style images based on text prompts. It has been updated for ease of use and can be used with negative prompts to create high-quality images.\'}', metadata={})]