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


 I want to build an AI that identifies the best marketing strategies for my website by trying different combinations of headlines and images.\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 team is working on a video game where the player needs to land the spaceship on the lunar surface without crashing. They want to implement an AI module that can play the game and test it.\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\': \'csarron/bert-base-uncased-squad-v1\', \'api_call\': "pipeline(\'question-answering\', model=\'csarron/bert-base-uncased-squad-v1\', tokenizer=\'csarron/bert-base-uncased-squad-v1\')", \'api_arguments\': {\'model\': \'csarron/bert-base-uncased-squad-v1\', \'tokenizer\': \'csarron/bert-base-uncased-squad-v1\'}, \'python_environment_requirements\': \'Python 3.7.5\', \'example_code\': "from transformers import pipeline\\nqa_pipeline = pipeline(\\n question-answering,\\n model=csarron/bert-base-uncased-squad-v1,\\n tokenizer=csarron/bert-base-uncased-squad-v1\\n)\\npredictions = qa_pipeline({\\n \'context\': The game was played on February 7, 2016 at Levi\'s Stadium in the San Francisco Bay Area at Santa Clara, California.,\\n \'question\': What day was the game played on?\\n})\\nprint(predictions)", \'performance\': {\'dataset\': \'SQuAD1.1\', \'accuracy\': {\'EM\': 80.9, \'F1\': 88.2}}, \'description\': \'BERT-base uncased model fine-tuned on SQuAD v1. This model is case-insensitive and does not make a difference between english and English.\'}', metadata={})]


 Develop an AI character that can play the SoccerTwos game with advanced strategies.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Reinforcement Learning\', \'framework\': \'Unity ML-Agents\', \'functionality\': \'Train and play SoccerTwos\', \'api_name\': \'Raiden-1001/poca-Soccerv7.1\', \'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\': [\'ml-agents\'], \'example_code\': \'mlagents-learn <your_configuration_file_path.yaml> --run-id=<run_id> --resume\', \'performance\': {\'dataset\': \'SoccerTwos\', \'accuracy\': \'Not provided\'}, \'description\': \'A trained model of a poca agent playing SoccerTwos using the Unity ML-Agents Library.\'}', metadata={})]


 Our gaming company is looking for a reinforcement learning solution to implement an artificial agent that can play SoccerTwos proficiently.\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={})]


 Develop a language understanding feature for a chatbot that can help tourists with information on visiting Indonesia.\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={})]


 I need to analyze images in real-time feeds from different locations for object recognition.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Reinforcement Learning Robotics\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'EmbodiedAI tasks, such as object manipulation and indoor navigation\', \'api_name\': \'facebook/vc1-large\', \'api_call\': "model_utils.load_model(\'model_utils.VC1_BASE_NAME\')", \'api_arguments\': \'img\', \'python_environment_requirements\': \'from vc_models.models.vit import model_utils\', \'example_code\': \'model,embd_size,model_transforms,model_info = model_utils.load_model(model_utils.VC1_BASE_NAME)\\nimg = your_function_here ...\\ntransformed_img = model_transforms(img)\\nembedding = model(transformed_img)\', \'performance\': {\'dataset\': \'CortexBench\', \'accuracy\': \'68.7 (Mean Success)\'}, \'description\': \'The VC-1 model is a vision transformer (ViT) pre-trained on over 4,000 hours of egocentric videos from 7 different sources, together with ImageNet. The model is trained using Masked Auto-Encoding (MAE) and is available in two sizes: ViT-B and ViT-L. The model is intended for use for EmbodiedAI tasks, such as object manipulation and indoor navigation.\'}', metadata={})]


 Our travel agency needs to build a chatbot that helps tourists find the best attractions in various destinations. The chatbot should answer questions related to tourist attractions.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'facebook/blenderbot-1B-distill\', \'api_call\': "AutoModelForSeq2SeqLM.from_pretrained(\'facebook/blenderbot-1B-distill\')", \'api_arguments\': {\'input_message\': \'string\'}, \'python_environment_requirements\': {\'library\': \'transformers\', \'version\': \'latest\'}, \'example_code\': "inputs = tokenizer(\'Hello, how are you?\', return_tensors=\'pt\'); outputs = model.generate(inputs[\'input_ids\']); decoded_output = tokenizer.decode(outputs[0], skip_special_tokens=True)", \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not mentioned\'}, \'description\': \'BlenderBot-1B is a large-scale open-domain chatbot model that can engage in conversations, ask and answer questions, and display knowledge, empathy, and personality. This distilled version is smaller and faster than the original 9.4B parameter model, making it more accessible for use.\'}', metadata={})]


 We want to develop a chatbot that can engage with multilingual users. Please help us create a model to encode sentences and understand user input in various languages.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'text-generation\', \'api_name\': \'pygmalion-1.3b\', \'api_call\': "pipeline(\'text-generation\', \'PygmalionAI/pygmalion-1.3b\')", \'api_arguments\': \'input_prompt\', \'python_environment_requirements\': [\'transformers\'], \'example_code\': "[CHARACTER]\'s Persona: [A few sentences about the character you want the model to play]\\n[DIALOGUE HISTORY]\\nYou: [Your input message here]\\n[CHARACTER]:", \'performance\': {\'dataset\': \'56MB of dialogue data\', \'accuracy\': \'Not provided\'}, \'description\': "Pygmalion 1.3B is a proof-of-concept dialogue model based on EleutherAI\'s pythia-1.3b-deduped. It is designed for generating conversational responses and can be used with a specific input format that includes character persona, dialogue history, and user input message."}', metadata={})]


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


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


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


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


 We need to generate a short video showing Spider-Man water skiing in redshift style based on a textual prompt.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Video\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-Video Synthesis\', \'api_name\': \'modelscope-damo-text-to-video-synthesis\', \'api_call\': "pipeline(\'text-to-video-synthesis\', model_dir.as_posix())", \'api_arguments\': {\'text\': \'A short text description in English\'}, \'python_environment_requirements\': [\'modelscope==1.4.2\', \'open_clip_torch\', \'pytorch-lightning\'], \'example_code\': "from huggingface_hub import snapshot_download\\nfrom modelscope.pipelines import pipeline\\nfrom modelscope.outputs import OutputKeys\\nimport pathlib\\n\\nmodel_dir = pathlib.Path(\'weights\')\\nsnapshot_download(\'damo-vilab/modelscope-damo-text-to-video-synthesis\',\\n repo_type=\'model\', local_dir=model_dir)\\n\\npipe = pipeline(\'text-to-video-synthesis\', model_dir.as_posix())\\n\\ntest_text = {\\n \'text\': \'A panda eating bamboo on a rock.\',\\n}\\n\\noutput_video_path = pipe(test_text,)[OutputKeys.OUTPUT_VIDEO]\\nprint(\'output_video_path:\', output_video_path)", \'performance\': {\'dataset\': \'Webvid, ImageNet, LAION5B\', \'accuracy\': \'Not provided\'}, \'description\': \'This model is based on a multi-stage text-to-video generation diffusion model, which inputs a description text and returns a video that matches the text description. Only English input is supported.\'}', metadata={})]


 Our company develops travel guides in Polish language. We are now planning to use artificial intelligence for quick captioning of Polish images.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Visual Question Answering\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'azwierzc/vilt-b32-finetuned-vqa-pl\', \'api_call\': "pipeline(\'visual-question-answering\', model=\'azwierzc/vilt-b32-finetuned-vqa-pl\')", \'api_arguments\': {\'image\': \'path_to_image\', \'question\': \'question_text\'}, \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'\', \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'A Visual Question Answering model fine-tuned on the Polish language.\'}', metadata={})]


 A user has difficulty in visualizing images and needs help answering questions about an image. We need a model to answer questions based on the image provided.\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={})]


 A real estate company wants to extract information from a scan of a property listing. They need a solution to recognize and retrieve critical information from the OCR of the scan.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Conversational\', \'api_name\': \'microsoft/GODEL-v1_1-large-seq2seq\', \'api_call\': "AutoModelForSeq2SeqLM.from_pretrained(\'microsoft/GODEL-v1_1-large-seq2seq\')", \'api_arguments\': {\'instruction\': \'Instruction: given a dialog context, you need to response empathically.\', \'knowledge\': \'\', \'dialog\': [\'Does money buy happiness?\', \'It is a question. Money buys you a lot of things, but not enough to buy happiness.\', \'What is the best way to buy happiness ?\']}, \'python_environment_requirements\': {\'transformers\': \'AutoTokenizer, AutoModelForSeq2SeqLM\'}, \'example_code\': "from transformers import AutoTokenizer, AutoModelForSeq2SeqLM\\ntokenizer = AutoTokenizer.from_pretrained(microsoft/GODEL-v1_1-large-seq2seq)\\nmodel = AutoModelForSeq2SeqLM.from_pretrained(microsoft/GODEL-v1_1-large-seq2seq)\\ndef generate(instruction, knowledge, dialog):\\n if knowledge != \'\':\\n knowledge = \'[KNOWLEDGE] \' + knowledge\\n dialog = \' EOS \'.join(dialog)\\n query = f{instruction} [CONTEXT] {dialog} {knowledge}\\n input_ids = tokenizer(f{query}, return_tensors=pt).input_ids\\n outputs = model.generate(input_ids, max_length=128, min_length=8, top_p=0.9, do_sample=True)\\n output = tokenizer.decode(outputs[0], skip_special_tokens=True)\\n return output\\n\\ninstruction = f\'Instruction: given a dialog context, you need to response empathically.\'\\nknowledge = \'\'\\ndialog = [\\n \'Does money buy happiness?\',\\n \'It is a question. Money buys you a lot of things, but not enough to buy happiness.\',\\n \'What is the best way to buy happiness ?\'\\n]\\nresponse = generate(instruction, knowledge, dialog)\\nprint(response)", \'performance\': {\'dataset\': \'Reddit discussion thread, instruction and knowledge grounded dialogs\', \'accuracy\': \'Not provided\'}, \'description\': \'GODEL is a large-scale pre-trained model for goal-directed dialogs. It is parameterized with a Transformer-based encoder-decoder model and trained for response generation grounded in external text, which allows more effective fine-tuning on dialog tasks that require conditioning the response on information that is external to the current conversation (e.g., a retrieved document). The pre-trained model can be efficiently fine-tuned and adapted to accomplish a new dialog task with a handful of task-specific dialogs. The v1.1 model is trained on 551M multi-turn dialogs from Reddit discussion thread, and 5M instruction and knowledge grounded dialogs.\'}', metadata={})]


 We want to utilize the machine learning model for predicting molecular properties in the drug discovery domain.\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 need to estimate the depth of a scene in an image using a pretrained model. Can you please suggest a way?\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={})]


 Our company is working on an autonomous robot and needs a solution to estimate the depth of objects in its environment.\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={})]


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


 Develop an image classifier for distinguishing images of cats and dogs.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Zero-Shot Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Zero-Shot Image Classification\', \'api_name\': \'laion/CLIP-ViT-B-32-laion2B-s34B-b79K\', \'api_call\': "pipeline(\'zero-shot-classification\', model=\'laion/CLIP-ViT-B-32-laion2B-s34B-b79K\')", \'api_arguments\': {\'image\': \'path/to/image\', \'class_names\': [\'class1\', \'class2\', \'class3\']}, \'python_environment_requirements\': {\'transformers\': \'>=4.0.0\'}, \'example_code\': "from transformers import pipeline; classifier = pipeline(\'zero-shot-classification\', model=\'laion/CLIP-ViT-B-32-laion2B-s34B-b79K\'); classifier(image=\'path/to/image\', class_names=[\'class1\', \'class2\', \'class3\'])", \'performance\': {\'dataset\': \'ImageNet-1k\', \'accuracy\': 66.6}, \'description\': \'A CLIP ViT-B/32 model trained with the LAION-2B English subset of LAION-5B using OpenCLIP. It enables researchers to better understand and explore zero-shot, arbitrary image classification. The model can be used for zero-shot image classification, image and text retrieval, among others.\'}', metadata={})]


 We are building AI glasses that should tell us about things that we are seeing with classifications. We want to use a visual transformer architecture.\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 marketing firm has asked us to build an application to classify social media images into various categories.\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={})]


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


 We are building an app to help Counter-Strike: Global Offensive players improve their gameplay. We need to detect players in a live game of CS:GO.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Object Detection\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Object Detection\', \'api_name\': \'keremberke/yolov8n-csgo-player-detection\', \'api_call\': "YOLO(\'keremberke/yolov8n-csgo-player-detection\')", \'api_arguments\': {\'image\': \'URL or local path to image\'}, \'python_environment_requirements\': \'pip install ultralyticsplus==0.0.23 ultralytics==8.0.21\', \'example_code\': "from ultralyticsplus import YOLO, render_result\\n\\nmodel = YOLO(\'keremberke/yolov8n-csgo-player-detection\')\\n\\nmodel.overrides[\'conf\'] = 0.25\\nmodel.overrides[\'iou\'] = 0.45\\nmodel.overrides[\'agnostic_nms\'] = False\\nmodel.overrides[\'max_det\'] = 1000\\n\\nimage = \'https://github.com/ultralytics/yolov5/raw/master/data/images/zidane.jpg\'\\n\\nresults = model.predict(image)\\n\\nprint(results[0].boxes)\\nrender = render_result(model=model, image=image, result=results[0])\\nrender.show()", \'performance\': {\'dataset\': \'csgo-object-detection\', \'accuracy\': 0.844}, \'description\': "A YOLOv8 model for detecting Counter-Strike: Global Offensive (CS:GO) players with supported labels: [\'ct\', \'cthead\', \'t\', \'thead\']."}', metadata={})]


 The security department needs assistance to detect suspicious objects and people using a zero-shot text-conditioned object detection system.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Object Detection\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'zero-shot-object-detection\', \'api_name\': \'google/owlvit-base-patch32\', \'api_call\': "OwlViTForObjectDetection.from_pretrained(\'google/owlvit-base-patch32\')", \'api_arguments\': {\'texts\': \'List of text queries\', \'images\': \'Image to be processed\'}, \'python_environment_requirements\': \'transformers\', \'example_code\': \'import requests\\nfrom PIL import Image\\nimport torch\\nfrom transformers import OwlViTProcessor, OwlViTForObjectDetection\\nprocessor = OwlViTProcessor.from_pretrained(google/owlvit-base-patch32)\\nmodel = OwlViTForObjectDetection.from_pretrained(google/owlvit-base-patch32)\\nurl = http://images.cocodataset.org/val2017/000000039769.jpg\\nimage = Image.open(requests.get(url, stream=True).raw)\\ntexts = [[a photo of a cat, a photo of a dog]]\\ninputs = processor(text=texts, images=image, return_tensors=pt)\\noutputs = model(**inputs)\\ntarget_sizes = torch.Tensor([image.size[::-1]])\\nresults = processor.post_process(outputs=outputs, target_sizes=target_sizes)\', \'performance\': {\'dataset\': \'COCO and OpenImages\', \'accuracy\': \'Not specified\'}, \'description\': \'OWL-ViT is a zero-shot text-conditioned object detection model that uses CLIP as its multi-modal backbone, with a ViT-like Transformer to get visual features and a causal language model to get the text features. The model can be used to query an image with one or multiple text queries.\'}', metadata={})]


 As a specialist in computer vision, we need to use the OwlViT model to identify objects in an image described by specific text phrases like \"a photo of a cat\" and \"a photo of a dog.\"\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Zero-Shot Image Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Zero-Shot Image Classification\', \'api_name\': \'openai/clip-vit-large-patch14\', \'api_call\': "CLIPModel.from_pretrained(\'openai/clip-vit-large-patch14\')", \'api_arguments\': {\'text\': [\'a photo of a cat\', \'a photo of a dog\'], \'images\': \'image\', \'return_tensors\': \'pt\', \'padding\': \'True\'}, \'python_environment_requirements\': {\'packages\': [\'PIL\', \'requests\', \'transformers\']}, \'example_code\': \'from PIL import Image\\nimport requests\\nfrom transformers import CLIPProcessor, CLIPModel\\nmodel = CLIPModel.from_pretrained(openai/clip-vit-large-patch14)\\nprocessor = CLIPProcessor.from_pretrained(openai/clip-vit-large-patch14)\\nurl = http://images.cocodataset.org/val2017/000000039769.jpg\\nimage = Image.open(requests.get(url, stream=True).raw)\\ninputs = processor(text=[a photo of a cat, a photo of a dog], images=image, return_tensors=pt, padding=True)\\noutputs = model(**inputs)\\nlogits_per_image = outputs.logits_per_image\\nprobs = logits_per_image.softmax(dim=1)\', \'performance\': {\'dataset\': [\'Food101\', \'CIFAR10\', \'CIFAR100\', \'Birdsnap\', \'SUN397\', \'Stanford Cars\', \'FGVC Aircraft\', \'VOC2007\', \'DTD\', \'Oxford-IIIT Pet dataset\', \'Caltech101\', \'Flowers102\', \'MNIST\', \'SVHN\', \'IIIT5K\', \'Hateful Memes\', \'SST-2\', \'UCF101\', \'Kinetics700\', \'Country211\', \'CLEVR Counting\', \'KITTI Distance\', \'STL-10\', \'RareAct\', \'Flickr30\', \'MSCOCO\', \'ImageNet\', \'ImageNet-A\', \'ImageNet-R\', \'ImageNet Sketch\', \'ObjectNet (ImageNet Overlap)\', \'Youtube-BB\', \'ImageNet-Vid\'], \'accuracy\': \'varies depending on the dataset\'}, \'description\': \'The CLIP model was developed by researchers at OpenAI to learn about what contributes to robustness in computer vision tasks. The model was also developed to test the ability of models to generalize to arbitrary image classification tasks in a zero-shot manner.\'}', metadata={})]


 A medical research team requests an automated procedure for detecting blood cells in microscopic images of blood samples. Develop a solution to address this need.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Object Detection\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Blood Cell Detection\', \'api_name\': \'keremberke/yolov8n-blood-cell-detection\', \'api_call\': "YOLO(\'keremberke/yolov8n-blood-cell-detection\')", \'api_arguments\': {\'conf\': 0.25, \'iou\': 0.45, \'agnostic_nms\': False, \'max_det\': 1000}, \'python_environment_requirements\': \'ultralyticsplus==0.0.23 ultralytics==8.0.21\', \'example_code\': "from ultralyticsplus import YOLO, render_result\\nmodel = YOLO(\'keremberke/yolov8n-blood-cell-detection\')\\nmodel.overrides[\'conf\'] = 0.25\\nmodel.overrides[\'iou\'] = 0.45\\nmodel.overrides[\'agnostic_nms\'] = False\\nmodel.overrides[\'max_det\'] = 1000\\nimage = \'https://github.com/ultralytics/yolov5/raw/master/data/images/zidane.jpg\'\\nresults = model.predict(image)\\nprint(results[0].boxes)\\nrender = render_result(model=model, image=image, result=results[0])\\nrender.show()", \'performance\': {\'dataset\': \'blood-cell-object-detection\', \'accuracy\': 0.893}, \'description\': \'This model detects blood cells in images, specifically Platelets, RBC, and WBC. It is based on the YOLOv8 architecture and trained on the blood-cell-object-detection dataset.\'}', metadata={})]


 Our client has a traffic camera system and wants to detect vehicles in the images captured. Implement a solution.\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={})]


 Detect the location of players in an image from a Counter-Strike: Global Offensive (CS:GO) game.\n###Input: image_path = \"path/to/your/csgo_image.jpg\"\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Object Detection\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Object Detection\', \'api_name\': \'keremberke/yolov8n-csgo-player-detection\', \'api_call\': "YOLO(\'keremberke/yolov8n-csgo-player-detection\')", \'api_arguments\': {\'image\': \'URL or local path to image\'}, \'python_environment_requirements\': \'pip install ultralyticsplus==0.0.23 ultralytics==8.0.21\', \'example_code\': "from ultralyticsplus import YOLO, render_result\\n\\nmodel = YOLO(\'keremberke/yolov8n-csgo-player-detection\')\\n\\nmodel.overrides[\'conf\'] = 0.25\\nmodel.overrides[\'iou\'] = 0.45\\nmodel.overrides[\'agnostic_nms\'] = False\\nmodel.overrides[\'max_det\'] = 1000\\n\\nimage = \'https://github.com/ultralytics/yolov5/raw/master/data/images/zidane.jpg\'\\n\\nresults = model.predict(image)\\n\\nprint(results[0].boxes)\\nrender = render_result(model=model, image=image, result=results[0])\\nrender.show()", \'performance\': {\'dataset\': \'csgo-object-detection\', \'accuracy\': 0.844}, \'description\': "A YOLOv8 model for detecting Counter-Strike: Global Offensive (CS:GO) players with supported labels: [\'ct\', \'cthead\', \'t\', \'thead\']."}', metadata={})]


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


 Our team is working on a project to develop autonomous vehicles. We need a model to identify different segments of an image captured from the vehicle's camera.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Question Answering\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Multilingual Question Answering\', \'api_name\': \'mrm8488/bert-multi-cased-finetuned-xquadv1\', \'api_call\': "pipeline(\'question-answering\', model=\'mrm8488/bert-multi-cased-finetuned-xquadv1\', tokenizer=\'mrm8488/bert-multi-cased-finetuned-xquadv1\')", \'api_arguments\': {\'context\': \'string\', \'question\': \'string\'}, \'python_environment_requirements\': [\'transformers\'], \'example_code\': "qa_pipeline({\\n \'context\': Manuel Romero has been working hardly in the repository hugginface/transformers lately,\\n \'question\': Who has been working hard for hugginface/transformers lately?\\n})", \'performance\': {\'dataset\': \'XQuAD\', \'accuracy\': \'Not provided\'}, \'description\': \'This model is a BERT (base-multilingual-cased) fine-tuned for multilingual Question Answering on 11 different languages using the XQuAD dataset and additional data augmentation techniques.\'}', metadata={})]


 A real estate agency needs an application that can transform the floor plan images into simple straight line drawings, simplifying the visualization of the properties.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Classification\', \'framework\': \'Keras\', \'functionality\': \'Structured data learning with TabTransformer\', \'api_name\': \'keras-io/tab_transformer\', \'api_call\': \'TabTransformer.from_config()\', \'api_arguments\': \'N/A\', \'python_environment_requirements\': \'Hugging Face\', \'example_code\': \'N/A\', \'performance\': {\'dataset\': \'United States Census Income Dataset\', \'accuracy\': \'N/A\'}, \'description\': "This model uses self-attention based Transformers structure followed by multiple feed forward layers to serve supervised and semi-supervised learning tasks on tabular data. The model\'s inputs can contain both numerical and categorical features. Categorical features are encoded into embedding vectors before being fed into a stack of Transformer blocks. The contextual embeddings of the categorical features after the final Transformer layer are concatenated with the input numerical features and fed into a final MLP block. A SoftMax function is applied at the end of the model."}', metadata={})]


 I'm working on creating images of various scenes based on their textual descriptions. The models should also consider the actual positions and poses of the objects in the scenes.\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={})]


 Develop a new product that uses machine learning to enhance the quality of low-resolution images by upscaling them to twice their size.\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 animal shelter needs an original cat image for a fundraising event poster. Generate the image.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Information Retrieval\', \'api_name\': \'cross-encoder/ms-marco-TinyBERT-L-2-v2\', \'api_call\': "AutoModelForSequenceClassification.from_pretrained(\'cross-encoder/ms-marco-TinyBERT-L-2-v2\')", \'api_arguments\': {\'tokenizer\': "tokenizer = AutoTokenizer.from_pretrained(\'model_name\')", \'features\': "features = tokenizer([\'How many people live in Berlin?\', \'How many people live in Berlin?\'], [\'Berlin has a population of 3,520,031 registered inhabitants in an area of 891.82 square kilometers.\', \'New York City is famous for the Metropolitan Museum of Art.\'], padding=True, truncation=True, return_tensors=\'pt\')"}, \'python_environment_requirements\': [\'transformers\', \'torch\'], \'example_code\': {\'import\': \'from transformers import AutoTokenizer, AutoModelForSequenceClassification\', \'model\': "model = AutoModelForSequenceClassification.from_pretrained(\'model_name\')", \'tokenizer\': "tokenizer = AutoTokenizer.from_pretrained(\'model_name\')", \'features\': "features = tokenizer([\'How many people live in Berlin?\', \'How many people live in Berlin?\'], [\'Berlin has a population of 3,520,031 registered inhabitants in an area of 891.82 square kilometers.\', \'New York City is famous for the Metropolitan Museum of Art.\'], padding=True, truncation=True, return_tensors=\'pt\')", \'scores\': \'with torch.no_grad():\\n    scores = model(**features).logits\\n    print(scores)\'}, \'performance\': {\'dataset\': \'TREC Deep Learning 2019\', \'accuracy\': \'69.84 (NDCG@10)\'}, \'description\': \'This model was trained on the MS Marco Passage Ranking task. It can be used for Information Retrieval: Given a query, encode the query with all possible passages (e.g. retrieved with ElasticSearch). Then sort the passages in a decreasing order. The training code is available here: SBERT.net Training MS Marco.\'}', metadata={})]


 Develop a video content recommendation engine that can understand and generate multiple categories, such as sports, comedy, and news, based on the videos.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Video\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-Video\', \'api_name\': \'camenduru/text2-video-zero\', \'api_call\': "pipeline(\'text-to-video\', model=\'camenduru/text2-video-zero\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'\', \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'This model is used for generating videos from text inputs. It is based on the Hugging Face framework and can be used with the transformers library. The model is trained on a variety of text and video datasets, and can be used for tasks such as video summarization, video generation from text prompts, and more.\'}', metadata={})]


 Our customer is a fitness platform. We need to analyze workout videos for offering customized workout plans.\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={})]


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


 Design a model to classify the following image: a city park with a playground and a lake, surrounded by trees and skyscrapers.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Table Question Answering\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'microsoft/tapex-large-sql-execution\', \'api_call\': "BartForConditionalGeneration.from_pretrained(\'microsoft/tapex-large-sql-execution\')", \'api_arguments\': {\'table\': \'pd.DataFrame\', \'query\': \'str\'}, \'python_environment_requirements\': [\'transformers\', \'pandas\'], \'example_code\': \'from transformers import TapexTokenizer, BartForConditionalGeneration\\nimport pandas as pd\\ntokenizer = TapexTokenizer.from_pretrained(microsoft/tapex-large-sql-execution)\\nmodel = BartForConditionalGeneration.from_pretrained(microsoft/tapex-large-sql-execution)\\ndata = {\\n year: [1896, 1900, 1904, 2004, 2008, 2012],\\n city: [athens, paris, st. louis, athens, beijing, london]\\n}\\ntable = pd.DataFrame.from_dict(data)\\nquery = select year where city = beijing\\nencoding = tokenizer(table=table, query=query, return_tensors=pt)\\noutputs = model.generate(**encoding)\\nprint(tokenizer.batch_decode(outputs, skip_special_tokens=True))\', \'performance\': {\'dataset\': \'synthetic corpus\', \'accuracy\': \'not specified\'}, \'description\': \'TAPEX (Table Pre-training via Execution) is a conceptually simple and empirically powerful pre-training approach to empower existing models with table reasoning skills. TAPEX realizes table pre-training by learning a neural SQL executor over a synthetic corpus, which is obtained by automatically synthesizing executable SQL queries. TAPEX is based on the BART architecture, the transformer encoder-encoder (seq2seq) model with a bidirectional (BERT-like) encoder and an autoregressive (GPT-like) decoder.\'}', metadata={})]


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


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


 Our organization sells movies. We need to collect reviews from various platforms to understand the popularity of a movie.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'results-yelp\', \'api_call\': "AutoTokenizer.from_pretrained(\'bert-base-uncased\')", \'api_arguments\': {\'tokenizer\': "AutoTokenizer.from_pretrained(\'bert-base-uncased\')", \'config\': "AutoConfig.from_pretrained(\'potatobunny/results-yelp\')"}, \'python_environment_requirements\': {\'Transformers\': \'4.18.0\', \'Pytorch\': \'1.10.0+cu111\', \'Datasets\': \'2.0.0\', \'Tokenizers\': \'0.12.1\'}, \'example_code\': \'\', \'performance\': {\'dataset\': \'Yelp\', \'accuracy\': 0.9302}, \'description\': \'This model is a fine-tuned version of textattack/bert-base-uncased-yelp-polarity on a filtered and manually reviewed Yelp dataset containing restaurant reviews only. It is intended to perform text classification, specifically sentiment analysis, on text data obtained from restaurant reviews to determine if the particular review is positive or negative.\'}', metadata={})]


 We want to enhance our search function by improving the ranking of search results.\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 developing an AI chatbot to interact with users. We need the bot to recognize the user's emotions based on their text input.\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={})]


 Please help me extract the names of people, organizations, and locations mentioned in the given text.\n###Input: Hello, my name is John Doe, and I work at Microsoft. Tomorrow, I'll be going to a conference in San Francisco.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Token Classification\', \'framework\': \'Transformers\', \'functionality\': \'Named Entity Recognition\', \'api_name\': \'dslim/bert-base-NER-uncased\', \'api_call\': "pipeline(\'ner\', model=\'dslim/bert-base-NER-uncased\')", \'api_arguments\': {}, \'python_environment_requirements\': {\'transformers\': \'>=4.0.0\'}, \'example_code\': "nlp(\'My name is John and I live in New York.\')", \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'A pretrained BERT model for Named Entity Recognition (NER) on uncased text. It can be used to extract entities such as person names, locations, and organizations from text.\'}', metadata={})]


 The school wants a tool to teach foreign students Chinese grammar. They want you to develop a part-of-speech tagging system to detect the words' grammatical roles.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Token Classification\', \'framework\': \'Flair\', \'functionality\': \'Part-of-Speech Tagging\', \'api_name\': \'flair/upos-english\', \'api_call\': "SequenceTagger.load(\'flair/upos-english\')", \'api_arguments\': [\'sentence\'], \'python_environment_requirements\': \'pip install flair\', \'example_code\': "from flair.data import Sentence\\nfrom flair.models import SequenceTagger\\ntagger = SequenceTagger.load(\'flair/upos-english\')\\nsentence = Sentence(\'I love Berlin.\')\\ntagger.predict(sentence)\\nprint(sentence)\\nfor entity in sentence.get_spans(\'pos\'):\\n    print(entity)", \'performance\': {\'dataset\': \'ontonotes\', \'accuracy\': 98.6}, \'description\': \'This is the standard universal part-of-speech tagging model for English that ships with Flair. It predicts universal POS tags such as ADJ, ADP, ADV, AUX, CCONJ, DET, INTJ, NOUN, NUM, PART, PRON, PROPN, PUNCT, SCONJ, SYM, VERB, and X. The model is based on Flair embeddings and LSTM-CRF.\'}', metadata={})]


 Our company collects data on the salesperson performance in different regions for each month. We want to use the most suitable API from our subscribed_huggingface.co to analyze that in specific table format and then based on provided question, answer accordingly.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'text-generation\', \'api_name\': \'pygmalion-2.7b\', \'api_call\': "pipeline(\'text-generation\', model=\'PygmalionAI/pygmalion-2.7b\')", \'api_arguments\': {\'input_prompt\': \'string\'}, \'python_environment_requirements\': {\'transformers\': \'latest\'}, \'example_code\': "model([CHARACTER]\'s Persona: [A few sentences about the character you want the model to play]<START>[DIALOGUE HISTORY]You: [Your input message here][CHARACTER]:)", \'performance\': {\'dataset\': \'56MB of dialogue data\', \'accuracy\': \'N/A\'}, \'description\': "Pygmalion 2.7B is a proof-of-concept dialogue model based on EleutherAI\'s gpt-neo-2.7B. It is fine-tuned on 56MB of dialogue data gathered from multiple sources, including real and partially machine-generated conversations. The model is intended for use in generating conversational responses and can be used with a specific input format that includes character persona, dialogue history, and user input message."}', metadata={})]


 Assist me in finding the accurate information in a table related to the Korean stock market.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Table Question Answering\', \'framework\': \'Transformers\', \'functionality\': \'Table Question Answering\', \'api_name\': \'google/tapas-medium-finetuned-sqa\', \'api_call\': "pipeline(\'table-question-answering\', model=\'google/tapas-medium-finetuned-sqa\')", \'api_arguments\': \'table, query\', \'python_environment_requirements\': \'transformers\', \'example_code\': "from transformers import pipeline\\n\\n# Initialize the pipeline\\ntable_qa_pipeline = pipeline(\'table-question-answering\', model=\'google/tapas-medium-finetuned-sqa\')\\n\\n# Provide the table and query\\nresult = table_qa_pipeline(table=table, query=\'What is the total revenue?\')", \'performance\': {\'dataset\': \'msr_sqa\', \'accuracy\': 0.6561}, \'description\': \'TAPAS medium model fine-tuned on Sequential Question Answering (SQA). This model is pretrained on a large corpus of English data from Wikipedia and uses relative position embeddings. It can be used for answering questions related to a table in a conversational set-up.\'}', metadata={})]


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


 We have a coffee shop with different types of coffee on the menu. Determine the caffeine levels in each cup of coffee.\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={})]


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


 I want to have a personal assistant app that can answer questions from a given text.\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\': \'deepset/roberta-large-squad2\', \'api_call\': "pipeline(\'question-answering\', model=\'deepset/roberta-large-squad2\')", \'api_arguments\': [\'question\', \'context\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import pipeline; nlp = pipeline(\'question-answering\', model=\'deepset/roberta-large-squad2\'); nlp({\'question\': \'What is the capital of Germany?\', \'context\': \'Berlin is the capital of Germany.\'})", \'performance\': {\'dataset\': \'squad_v2\', \'accuracy\': \'Not provided\'}, \'description\': \'A pre-trained RoBERTa model for question answering tasks, specifically trained on the SQuAD v2 dataset. It can be used to answer questions based on a given context.\'}', metadata={})]


 I want to build a tool that helps me answer questions about specific information in a Korean newspaper article.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'text-generation\', \'api_name\': \'pygmalion-1.3b\', \'api_call\': "pipeline(\'text-generation\', \'PygmalionAI/pygmalion-1.3b\')", \'api_arguments\': \'input_prompt\', \'python_environment_requirements\': [\'transformers\'], \'example_code\': "[CHARACTER]\'s Persona: [A few sentences about the character you want the model to play]\\n[DIALOGUE HISTORY]\\nYou: [Your input message here]\\n[CHARACTER]:", \'performance\': {\'dataset\': \'56MB of dialogue data\', \'accuracy\': \'Not provided\'}, \'description\': "Pygmalion 1.3B is a proof-of-concept dialogue model based on EleutherAI\'s pythia-1.3b-deduped. It is designed for generating conversational responses and can be used with a specific input format that includes character persona, dialogue history, and user input message."}', metadata={})]


 Develop a tool to help our team members find answers to essential questions from a long document.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Summarization\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'text2text-generation\', \'api_name\': \'google/bigbird-pegasus-large-bigpatent\', \'api_call\': "BigBirdPegasusForConditionalGeneration.from_pretrained(\'google/bigbird-pegasus-large-bigpatent\')", \'api_arguments\': {\'attention_type\': \'original_full\', \'block_size\': 16, \'num_random_blocks\': 2}, \'python_environment_requirements\': \'transformers\', \'example_code\': "from transformers import BigBirdPegasusForConditionalGeneration, AutoTokenizer\\ntokenizer = AutoTokenizer.from_pretrained(google/bigbird-pegasus-large-bigpatent)\\nmodel = BigBirdPegasusForConditionalGeneration.from_pretrained(google/bigbird-pegasus-large-bigpatent)\\ntext = Replace me by any text you\'d like.\\ninputs = tokenizer(text, return_tensors=\'pt\')\\nprediction = model.generate(**inputs)\\nprediction = tokenizer.batch_decode(prediction)", \'performance\': {\'dataset\': \'big_patent\', \'accuracy\': \'Not provided\'}, \'description\': \'BigBird, a sparse-attention based transformer, extends Transformer-based models like BERT to much longer sequences. It can handle sequences up to a length of 4096 at a much lower compute cost compared to BERT. BigBird has achieved state-of-the-art results on various tasks involving very long sequences such as long documents summarization and question-answering with long contexts.\'}', metadata={})]