 I need assistance in predicting carbon emissions of a city based on historical data. Use the dataset provided to predict future carbon emissions.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Classification\', \'framework\': \'Hugging Face\', \'functionality\': \'Carbon Emissions\', \'api_name\': \'Xinhhd/autotrain-zhongxin-contest-49402119333\', \'api_call\': "AutoModel.from_pretrained(\'Xinhhd/autotrain-zhongxin-contest-49402119333\')", \'api_arguments\': [\'data\'], \'python_environment_requirements\': [\'joblib\', \'pandas\'], \'example_code\': "import json\\nimport joblib\\nimport pandas as pd\\nmodel = joblib.load(\'model.joblib\')\\nconfig = json.load(open(\'config.json\'))\\nfeatures = config[\'features\']\\ndata = pd.read_csv(\'data.csv\')\\ndata = data[features]\\ndata.columns = [\'feat_\' + str(col) for col in data.columns]\\npredictions = model.predict(data)", \'performance\': {\'dataset\': \'Xinhhd/autotrain-data-zhongxin-contest\', \'accuracy\': 0.889}, \'description\': \'A multi-class classification model trained with AutoTrain to predict carbon emissions based on input features.\'}', metadata={})]


 We have some clients asking for estimating CO2 emissions based on their historic data, which is in a CSV file.\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={})]


 Determine the electricity consumption of a residential area based on historical data.\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={})]


 A soccer simulation company wants to use a reinforcement learning agent that can play SoccerTwos effectively.\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={})]


 Our company is developing a game, and they want to include an AI agent to play the game. We need to evaluate its performance on the CartPole-v1 environment for consistency.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Reinforcement Learning\', \'framework\': \'Stable-Baselines3\', \'functionality\': \'CartPole-v1\', \'api_name\': \'dqn-CartPole-v1\', \'api_call\': "load_from_hub(repo_id=\'sb3/dqn-CartPole-v1\',filename=\'{MODEL FILENAME}.zip\',)", \'api_arguments\': [\'algo\', \'env\', \'logs\'], \'python_environment_requirements\': [\'rl_zoo3\', \'stable-baselines3\', \'stable-baselines3-contrib\'], \'example_code\': \'python train.py --algo dqn --env CartPole-v1 -f logs/\', \'performance\': {\'dataset\': \'CartPole-v1\', \'accuracy\': \'500.00 +/- 0.00\'}, \'description\': \'This is a trained model of a DQN agent playing CartPole-v1 using the stable-baselines3 library and the RL Zoo. The RL Zoo is a training framework for Stable Baselines3 reinforcement learning agents, with hyperparameter optimization and pre-trained agents included.\'}', metadata={})]


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


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


 We want to automatically generate hashtags for the provided image URL to improve social media post performance.\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 am building a recommendation engine for TV shows. Can you evaluate the TV shows using a BERT-based model trained on sentence embedding to find the most similar TV shows based on description?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Summarization\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Text Summarization\', \'api_name\': \'distilbart-cnn-12-6-samsum\', \'api_call\': "pipeline(\'summarization\', model=\'philschmid/distilbart-cnn-12-6-samsum\')", \'api_arguments\': {\'model\': \'philschmid/distilbart-cnn-12-6-samsum\'}, \'python_environment_requirements\': \'transformers\', \'example_code\': "from transformers import pipeline\\nsummarizer = pipeline(summarization, model=philschmid/distilbart-cnn-12-6-samsum)\\nconversation = \'\'\'Jeff: Can I train a 🤗 Transformers model on Amazon SageMaker? \\nPhilipp: Sure you can use the new Hugging Face Deep Learning Container. \\nJeff: ok.\\nJeff: and how can I get started? \\nJeff: where can I find documentation? \\nPhilipp: ok, ok you can find everything here. https://huggingface.co/blog/the-partnership-amazon-sagemaker-and-hugging-face <br />\\n\'\'\'\\nsummarizer(conversation)", \'performance\': {\'dataset\': \'samsum\', \'accuracy\': {\'ROUGE-1\': 41.09, \'ROUGE-2\': 20.746, \'ROUGE-L\': 31.595, \'ROUGE-LSUM\': 38.339}}, \'description\': \'This model is a DistilBART-based text summarization model trained on the SAMsum dataset. It can be used to generate summaries of conversational text.\'}', metadata={})]


 I want to create a solution that can answer questions related to an image of my pet dogs.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Visual Question Answering\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'ivelin/donut-refexp-combined-v1\', \'api_call\': "pipeline(\'visual-question-answering\', model=\'ivelin/donut-refexp-combined-v1\')", \'api_arguments\': \'image, question\', \'python_environment_requirements\': \'transformers\', \'example_code\': "vqa(image=\'path/to/image.jpg\', question=\'What is the color of the object?\')", \'performance\': {\'dataset\': \'ivelin/donut-refexp-combined-v1\', \'accuracy\': \'N/A\'}, \'description\': \'A visual question answering model that takes an image and a question as input and provides an answer based on the visual content of the image and the context of the question.\'}', metadata={})]


 Design an explanation on how to use Pix2Struct to analyze and generate text based on visuals such as graphs and charts.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Image\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-Image Generation\', \'api_name\': \'stabilityai/stable-diffusion-2\', \'api_call\': "StableDiffusionPipeline.from_pretrained(\'stabilityai/stable-diffusion-2\', scheduler=EulerDiscreteScheduler.from_pretrained(\'stabilityai/stable-diffusion-2\', subfolder=scheduler), torch_dtype=torch.float16)", \'api_arguments\': {\'prompt\': \'a photo of an astronaut riding a horse on mars\'}, \'python_environment_requirements\': [\'diffusers\', \'transformers\', \'accelerate\', \'scipy\', \'safetensors\'], \'example_code\': \'from diffusers import StableDiffusionPipeline, EulerDiscreteScheduler\\nmodel_id = stabilityai/stable-diffusion-2\\nscheduler = EulerDiscreteScheduler.from_pretrained(model_id, subfolder=scheduler)\\npipe = StableDiffusionPipeline.from_pretrained(model_id, scheduler=scheduler, torch_dtype=torch.float16)\\npipe = pipe.to(cuda)\\nprompt = a photo of an astronaut riding a horse on mars\\nimage = pipe(prompt).images[0]\\nimage.save(astronaut_rides_horse.png)\', \'performance\': {\'dataset\': \'COCO2017 validation set\', \'accuracy\': \'Not optimized for FID scores\'}, \'description\': \'Stable Diffusion v2 is a diffusion-based text-to-image generation model that can generate and modify images based on text prompts. It uses a fixed, pretrained text encoder (OpenCLIP-ViT/H) and is primarily intended for research purposes, such as safe deployment of models with potential to generate harmful content, understanding limitations and biases of generative models, and generation of artworks for design and artistic processes.\'}', metadata={})]


 Design a product that allows users to read street signs in a foreign language.\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\': \'patrickjohncyh/fashion-clip\', \'api_call\': "CLIPModel.from_pretrained(\'patrickjohncyh/fashion-clip\')", \'api_arguments\': {\'image\': \'File\', \'class_names\': \'String (comma-separated)\'}, \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import CLIPProcessor, CLIPModel; model = CLIPModel.from_pretrained(\'patrickjohncyh/fashion-clip\'); processor = CLIPProcessor.from_pretrained(\'patrickjohncyh/fashion-clip\'); inputs = processor(text=\'blue shoes\', images=image, return_tensors=\'pt\', padding=True); logits_per_image = model(**inputs).logits_per_image; probs = logits_per_image.softmax(dim=-1).tolist()[0]", \'performance\': {\'dataset\': [{\'name\': \'FMNIST\', \'accuracy\': 0.83}, {\'name\': \'KAGL\', \'accuracy\': 0.73}, {\'name\': \'DEEP\', \'accuracy\': 0.62}]}, \'description\': \'FashionCLIP is a CLIP-based model developed to produce general product representations for fashion concepts. Leveraging the pre-trained checkpoint (ViT-B/32) released by OpenAI, it is trained on a large, high-quality novel fashion dataset to study whether domain specific fine-tuning of CLIP-like models is sufficient to produce product representations that are zero-shot transferable to entirely new datasets and tasks.\'}', metadata={})]


 I have a text question about an image, and I would like to receive an appropriate answer.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Translation\', \'framework\': \'Transformers\', \'functionality\': \'Text-to-Text Generation\', \'api_name\': \'optimum/t5-small\', \'api_call\': "ORTModelForSeq2SeqLM.from_pretrained(\'optimum/t5-small\')", \'api_arguments\': [\'text\'], \'python_environment_requirements\': [\'transformers\', \'optimum.onnxruntime\'], \'example_code\': \'from transformers import AutoTokenizer, pipeline\\nfrom optimum.onnxruntime import ORTModelForSeq2SeqLM\\ntokenizer = AutoTokenizer.from_pretrained(optimum/t5-small)\\nmodel = ORTModelForSeq2SeqLM.from_pretrained(optimum/t5-small)\\ntranslator = pipeline(translation_en_to_fr, model=model, tokenizer=tokenizer)\\nresults = translator(My name is Eustache and I have a pet raccoon)\\nprint(results)\', \'performance\': {\'dataset\': \'c4\', \'accuracy\': \'N/A\'}, \'description\': \'T5 is an encoder-decoder model pre-trained on a multi-task mixture of unsupervised and supervised tasks and for which each task is converted into a text-to-text format. It can be used for translation, text-to-text generation, and summarization.\'}', metadata={})]


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


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


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


 Calculate the distance between the objects in an image for an autonomous vehicle driving in a parking lot.\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={})]


 We want a technology to be developed in the field of autonomous vehicles. Provide an example to estimate the depth of the environment using monocular images.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Image\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-Image\', \'api_name\': \'dreamlike-art/dreamlike-photoreal-2.0\', \'api_call\': "StableDiffusionPipeline.from_pretrained(\'dreamlike-art/dreamlike-photoreal-2.0\', torch_dtype=torch.float16)(prompt).images[0]", \'api_arguments\': {\'prompt\': \'photo, a church in the middle of a field of crops, bright cinematic lighting, gopro, fisheye lens\'}, \'python_environment_requirements\': {\'torch\': \'torch.float16\', \'diffusers\': \'StableDiffusionPipeline\'}, \'example_code\': \'from diffusers import StableDiffusionPipeline\\nimport torch\\nmodel_id = dreamlike-art/dreamlike-photoreal-2.0\\npipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)\\npipe = pipe.to(cuda)\\nprompt = photo, a church in the middle of a field of crops, bright cinematic lighting, gopro, fisheye lens\\nimage = pipe(prompt).images[0]\\nimage.save(./result.jpg)\', \'performance\': {\'dataset\': \'Stable Diffusion 1.5\', \'accuracy\': \'Not specified\'}, \'description\': \'Dreamlike Photoreal 2.0 is a photorealistic model based on Stable Diffusion 1.5, made by dreamlike.art. It can be used to generate photorealistic images from text prompts.\'}', metadata={})]


 As a construction company, we want to have a system to estimate the depth of images taken from different construction sites.\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={})]


 Our team has built a Japanese language learning app for students. We want to make sure that the user-submitted image is an anime art created by humans and not AI-generated.\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 classify the type of an image for an inventory.\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={})]


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


 We are building an AI-based camera system to ensure safety on a construction site. Detect workers wearing hard hats in a given image.\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/yolov8m-hard-hat-detection\', \'api_call\': "YOLO(\'keremberke/yolov8m-hard-hat-detection\')", \'api_arguments\': {\'image\': \'URL or local path to the image\'}, \'python_environment_requirements\': [\'ultralyticsplus==0.0.24\', \'ultralytics==8.0.23\'], \'example_code\': "from ultralyticsplus import YOLO, render_result\\n\\nmodel = YOLO(\'keremberke/yolov8m-hard-hat-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\': \'hard-hat-detection\', \'accuracy\': 0.811}, \'description\': "A YOLOv8 model for detecting hard hats in images. The model can distinguish between \'Hardhat\' and \'NO-Hardhat\' classes. It can be used to ensure safety compliance in construction sites or other industrial environments where hard hats are required."}', metadata={})]


My client needs help with security. They have a surveillance camera set up and we need to identify if any unknown person enters their property.\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 a system to control the access into parking lot. Analyze an image and find out the license plate numbers to detect whether it's an authorized vehicle or not.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Document Question Answer\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'vision-encoder-decoder\', \'api_name\': \'naver-clova-ix/donut-base-finetuned-docvqa\', \'api_call\': "pipeline(\'document-question-answering\', model=\'donut-base-finetuned-docvqa\')", \'api_arguments\': {\'image\': \'path_to_image\', \'question\': \'your_question\'}, \'python_environment_requirements\': \'Transformers\', \'example_code\': "from transformers import pipeline\\n\\n# Initialize the pipeline\\ndoc_qa = pipeline(\'document-question-answering\', model=\'naver-clova-ix/donut-base-finetuned-docvqa\')\\n\\n# Load an image and ask a question\\nimage_path = \'path_to_image\'\\nquestion = \'your_question\'\\n\\n# Get the answer\\nanswer = doc_qa({\'image\': image_path, \'question\': question})\\nprint(answer)", \'performance\': {\'dataset\': \'DocVQA\', \'accuracy\': \'Not provided\'}, \'description\': \'Donut model fine-tuned on DocVQA. It was introduced in the paper OCR-free Document Understanding Transformer by Geewok et al. and first released in this repository. Donut consists of a vision encoder (Swin Transformer) and a text decoder (BART). Given an image, the encoder first encodes the image into a tensor of embeddings (of shape batch_size, seq_len, hidden_size), after which the decoder autoregressively generates text, conditioned on the encoding of the encoder.\'}', metadata={})]


 Analyze an image of an urban scene to identify and separate regions with different semantics, such as streets, pedestrians, buildings, and vehicles.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Unconditional Image Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Denoising Diffusion Probabilistic Models (DDPM)\', \'api_name\': \'google/ddpm-ema-cat-256\', \'api_call\': "DDPMPipeline.from_pretrained(\'google/ddpm-ema-cat-256\')", \'api_arguments\': [\'model_id\'], \'python_environment_requirements\': [\'!pip install diffusers\'], \'example_code\': \'from diffusers import DDPMPipeline, DDIMPipeline, PNDMPipeline\\nmodel_id = google/ddpm-ema-cat-256\\nddpm = DDPMPipeline.from_pretrained(model_id)\\nimage = ddpm().images[0]\\nimage.save(ddpm_generated_image.png)\', \'performance\': {\'dataset\': \'CIFAR10\', \'accuracy\': {\'Inception_score\': 9.46, \'FID_score\': 3.17}}, \'description\': \'Denoising Diffusion Probabilistic Models (DDPM) is a class of latent variable models inspired by considerations from nonequilibrium thermodynamics. It can generate high-quality images, and supports different noise schedulers such as scheduling_ddpm, scheduling_ddim, and scheduling_pndm. On the unconditional CIFAR10 dataset, it achieves an Inception score of 9.46 and a state-of-the-art FID score of 3.17.\'}', metadata={})]


 We are developing an application to help customers visualize themselves wearing clothes available on our e-commerce website. We need identification of clothing items in the image.\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 an image segmentation solution for our smart city planning project. The solution should be able to handle different types of segmentation tasks, from semantic to instance to panoptic.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Segmentation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'facebook/mask2former-swin-tiny-coco-instance\', \'api_call\': "Mask2FormerForUniversalSegmentation.from_pretrained(\'facebook/mask2former-swin-tiny-coco-instance\')", \'api_arguments\': {\'pretrained_model_name_or_path\': \'facebook/mask2former-swin-tiny-coco-instance\'}, \'python_environment_requirements\': [\'torch\', \'transformers\', \'PIL\', \'requests\'], \'example_code\': "processor = AutoImageProcessor.from_pretrained(\'facebook/mask2former-swin-tiny-coco-instance\')\\nmodel = Mask2FormerForUniversalSegmentation.from_pretrained(\'facebook/mask2former-swin-tiny-coco-instance\')\\nurl = \'http://images.cocodataset.org/val2017/000000039769.jpg\'\\nimage = Image.open(requests.get(url, stream=True).raw)\\ninputs = processor(images=image, return_tensors=\'pt\')\\nwith torch.no_grad():\\n    outputs = model(**inputs)\\nclass_queries_logits = outputs.class_queries_logits\\nmasks_queries_logits = outputs.masks_queries_logits\\nresult = processor.post_process_instance_segmentation(outputs, target_sizes=[image.size[::-1]])[0]\\npredicted_instance_map = result[\'segmentation\']", \'performance\': {\'dataset\': \'COCO\', \'accuracy\': \'Not specified\'}, \'description\': \'Mask2Former model trained on COCO instance segmentation (tiny-sized version, Swin backbone). It was introduced in the paper Masked-attention Mask Transformer for Universal Image Segmentation and first released in this repository. This model addresses instance, semantic and panoptic segmentation with the same paradigm: by predicting a set of masks and corresponding labels. You can use this particular checkpoint for instance segmentation.\'}', metadata={})]


 We have a road safety app that helps identify potholes. Can we use an image segmentation model to detect if there are potholes in the pictures of roads?\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 making a mobile app related to fitness. We need to estimate the human pose from an image of a user performing an exercise.\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 wish to edit my images by detecting straight lines and controlling the diffusion models in the image's diffusion process.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Unconditional Image Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Denoising Diffusion Probabilistic Models (DDPM)\', \'api_name\': \'google/ddpm-bedroom-256\', \'api_call\': "DDPMPipeline.from_pretrained(\'google/ddpm-bedroom-256\')", \'api_arguments\': \'None\', \'python_environment_requirements\': \'diffusers\', \'example_code\': \'!pip install diffusers\\nfrom diffusers import DDPMPipeline, DDIMPipeline, PNDMPipeline\\nmodel_id = google/ddpm-bedroom-256\\nddpm = DDPMPipeline.from_pretrained(model_id)\\nimage = ddpm().images[0]\\nimage.save(ddpm_generated_image.png)\', \'performance\': {\'dataset\': \'CIFAR10\', \'accuracy\': {\'Inception score\': 9.46, \'FID score\': 3.17}}, \'description\': \'We present high quality image synthesis results using diffusion probabilistic models, a class of latent variable models inspired by considerations from nonequilibrium thermodynamics. Our best results are obtained by training on a weighted variational bound designed according to a novel connection between diffusion probabilistic models and denoising score matching with Langevin dynamics, and our models naturally admit a progressive lossy decompression scheme that can be interpreted as a generalization of autoregressive decoding. On the unconditional CIFAR10 dataset, we obtain an Inception score of 9.46 and a state-of-the-art FID score of 3.17. On 256x256 LSUN, we obtain sample quality similar to ProgressiveGAN.\'}', metadata={})]


 A photographer wants to create artistic interpretations of some of her pictures. Let's help her to get variated styles of her image.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Summarization\', \'api_name\': \'lidiya/bart-large-xsum-samsum\', \'api_call\': "pipeline(\'summarization\', model=\'lidiya/bart-large-xsum-samsum\')", \'api_arguments\': \'conversation\', \'python_environment_requirements\': \'transformers\', \'example_code\': "from transformers import pipeline\\nsummarizer = pipeline(summarization, model=lidiya/bart-large-xsum-samsum)\\nconversation = \'\'\'Hannah: Hey, do you have Betty\'s number?\\nAmanda: Lemme check\\nAmanda: Sorry, can\'t find it.\\nAmanda: Ask Larry\\nAmanda: He called her last time we were at the park together\\nHannah: I don\'t know him well\\nAmanda: Don\'t be shy, he\'s very nice\\nHannah: If you say so..\\nHannah: I\'d rather you texted him\\nAmanda: Just text him 🙂\\nHannah: Urgh.. Alright\\nHannah: Bye\\nAmanda: Bye bye <br />\\n\'\'\'\\nsummarizer(conversation)", \'performance\': {\'dataset\': \'SAMSum Corpus: A Human-annotated Dialogue Dataset for Abstractive Summarization\', \'accuracy\': {\'rouge1\': 53.306, \'rouge2\': 28.355, \'rougeL\': 44.095}}, \'description\': \'This model was obtained by fine-tuning facebook/bart-large-xsum on Samsum dataset.\'}', metadata={})]


 We have a client that manages a car website for selling used cars and they need new images of cars for the website.\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 am interested in building a wall of generated pictures for my gallery. My specifications include a size of 256x256 pixels.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Transformers\', \'functionality\': \'Sentence Correction\', \'api_name\': \'flexudy/t5-base-multi-sentence-doctor\', \'api_call\': "AutoModelWithLMHead.from_pretrained(\'flexudy/t5-base-multi-sentence-doctor\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'from transformers import AutoTokenizer, AutoModelWithLMHead\\ntokenizer = AutoTokenizer.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\nmodel = AutoModelWithLMHead.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\ninput_text = repair_sentence: m a medical doct context: {That is my job I a}{or I save lives} </s>\\ninput_ids = tokenizer.encode(input_text, return_tensors=pt)\\noutputs = model.generate(input_ids, max_length=32, num_beams=1)\\nsentence = tokenizer.decode(outputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)\\nassert sentence == I am a medical doctor.\', \'performance\': {\'dataset\': \'tatoeba\', \'accuracy\': \'Not specified\'}, \'description\': \'Sentence doctor is a T5 model that attempts to correct the errors or mistakes found in sentences. Model works on English, German and French text.\'}', metadata={})]


 We are a product company selling personalized gadgets, and we want to build a recommender system that shows generated, high-resolution images of human faces on our website.\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-based software that can identify the activities or actions in a video clip.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Transformers\', \'functionality\': \'Sentence Correction\', \'api_name\': \'flexudy/t5-base-multi-sentence-doctor\', \'api_call\': "AutoModelWithLMHead.from_pretrained(\'flexudy/t5-base-multi-sentence-doctor\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'from transformers import AutoTokenizer, AutoModelWithLMHead\\ntokenizer = AutoTokenizer.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\nmodel = AutoModelWithLMHead.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\ninput_text = repair_sentence: m a medical doct context: {That is my job I a}{or I save lives} </s>\\ninput_ids = tokenizer.encode(input_text, return_tensors=pt)\\noutputs = model.generate(input_ids, max_length=32, num_beams=1)\\nsentence = tokenizer.decode(outputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)\\nassert sentence == I am a medical doctor.\', \'performance\': {\'dataset\': \'tatoeba\', \'accuracy\': \'Not specified\'}, \'description\': \'Sentence doctor is a T5 model that attempts to correct the errors or mistakes found in sentences. Model works on English, German and French text.\'}', metadata={})]


The marketing team wants a tool to quickly classify new advertisement videos.\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={})]


 A sports league wants to analyze their videos and extract information on game highlights.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'PyTorch Transformers\', \'functionality\': \'text-generation\', \'api_name\': \'satvikag/chatbot\', \'api_call\': "AutoModelWithLMHead.from_pretrained(\'output-small\')", \'api_arguments\': {\'tokenizer\': "AutoTokenizer.from_pretrained(\'microsoft/DialoGPT-small\')", \'model\': "AutoModelWithLMHead.from_pretrained(\'output-small\')"}, \'python_environment_requirements\': [\'torch\', \'transformers\'], \'example_code\': "for step in range(100):\\n  new_user_input_ids = tokenizer.encode(input(\'>> User:\') + tokenizer.eos_token, return_tensors=\'pt\')\\n  bot_input_ids = torch.cat([chat_history_ids, new_user_input_ids], dim=-1) if step > 0 else new_user_input_ids\\n  chat_history_ids = model.generate(bot_input_ids, max_length=500, pad_token_id=tokenizer.eos_token_id, no_repeat_ngram_size=3, do_sample=True, top_k=100, top_p=0.7, temperature = 0.8)\\n  print(\'AI: {}\'.format(tokenizer.decode(chat_history_ids[:, bot_input_ids.shape[-1]:][0], skip_special_tokens=True)))", \'performance\': {\'dataset\': \'Kaggle game script dataset\', \'accuracy\': \'Not provided\'}, \'description\': \'DialoGPT Trained on the Speech of a Game Character, Joshua from The World Ends With You.\'}', metadata={})]


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


 My organization wants to create a video categorization tool to classify and categorize various videos. Utilize the appropriate API to build this video classifier.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Video Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Video Classification\', \'api_name\': \'facebook/timesformer-base-finetuned-k400\', \'api_call\': "TimesformerForVideoClassification.from_pretrained(\'facebook/timesformer-base-finetuned-k400\')", \'api_arguments\': \'video, return_tensors\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'from transformers import AutoImageProcessor, TimesformerForVideoClassification\\nimport numpy as np\\nimport torch\\nvideo = list(np.random.randn(8, 3, 224, 224))\\nprocessor = AutoImageProcessor.from_pretrained(facebook/timesformer-base-finetuned-k400)\\nmodel = TimesformerForVideoClassification.from_pretrained(facebook/timesformer-base-finetuned-k400)\\ninputs = processor(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\': \'Kinetics-400\', \'accuracy\': \'Not provided\'}, \'description\': \'TimeSformer is a video classification model pre-trained on Kinetics-400. It was introduced in the paper TimeSformer: Is Space-Time Attention All You Need for Video Understanding? by Tong et al. and first released in this repository. The model can be used for video classification into one of the 400 possible Kinetics-400 labels.\'}', metadata={})]


 We have a surveillance camera in our backyard. We would like to analyze the captured videos to recognize the activities taking place in the backyard.\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 classify an image's content and check if it contains a cat or a dog.\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={})]


 Analyze the type of plants in the image provided and provide the name of the probable plant.\n
 Use this API documentation for reference: [Document(page_content="{'domain': 'Natural Language Processing Token Classification', 'framework': 'Transformers', 'functionality': 'punctuation prediction', 'api_name': 'oliverguhr/fullstop-punctuation-multilang-large', 'api_call': 'PunctuationModel()', 'api_arguments': ['text'], 'python_environment_requirements': ['pip install deepmultilingualpunctuation'], 'example_code': 'from deepmultilingualpunctuation import PunctuationModel\\nmodel = PunctuationModel()\\ntext = My name is Clara and I live in Berkeley California Ist das eine Frage Frau Müller\\nresult = model.restore_punctuation(text)\\nprint(result)', 'performance': {'dataset': 'wmt/europarl', 'EN_accuracy': 0.775, 'DE_accuracy': 0.814, 'FR_accuracy': 0.782, 'IT_accuracy': 0.762}, 'description': 'This model predicts the punctuation of English, Italian, French and German texts. It was developed to restore the punctuation of transcribed spoken language and trained on the Europarl Dataset provided by the SEPP-NLG Shared Task. The model restores the following punctuation markers: ., ,, ?, -, :.'}", metadata={})]


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


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


 Our customer wants to analyze the sentiment of their customers' feedback. The feedback is in Spanish.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'financial-sentiment-analysis\', \'api_name\': \'ProsusAI/finbert\', \'api_call\': "AutoModelForSequenceClassification.from_pretrained(\'ProsusAI/finbert\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': "from transformers import pipeline; classifier = pipeline(\'sentiment-analysis\', model=\'ProsusAI/finbert\'); classifier(\'your_text_here\')", \'performance\': {\'dataset\': \'Financial PhraseBank\', \'accuracy\': \'Not provided\'}, \'description\': \'FinBERT is a pre-trained NLP model to analyze sentiment of financial text. It is built by further training the BERT language model in the finance domain, using a large financial corpus and thereby fine-tuning it for financial sentiment classification. Financial PhraseBank by Malo et al. (2014) is used for fine-tuning.\'}', metadata={})]


 A stock investor is looking to analyze the sentiment of a stock forum, such as StockTwits, to gain insights into the market sentiment for a specific stock.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'financial-sentiment-analysis\', \'api_name\': \'ProsusAI/finbert\', \'api_call\': "AutoModelForSequenceClassification.from_pretrained(\'ProsusAI/finbert\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': "from transformers import pipeline; classifier = pipeline(\'sentiment-analysis\', model=\'ProsusAI/finbert\'); classifier(\'your_text_here\')", \'performance\': {\'dataset\': \'Financial PhraseBank\', \'accuracy\': \'Not provided\'}, \'description\': \'FinBERT is a pre-trained NLP model to analyze sentiment of financial text. It is built by further training the BERT language model in the finance domain, using a large financial corpus and thereby fine-tuning it for financial sentiment classification. Financial PhraseBank by Malo et al. (2014) is used for fine-tuning.\'}', metadata={})]


 A forum moderator wants a tool to assess user-generated comments for toxic content. How does this model help?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Video Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Video Classification\', \'api_name\': \'MCG-NJU/videomae-base-finetuned-ssv2\', \'api_call\': "VideoMAEForVideoClassification.from_pretrained(\'MCG-NJU/videomae-base-finetuned-ssv2\')", \'api_arguments\': \'video\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'from transformers import VideoMAEImageProcessor, VideoMAEForVideoClassification\\nimport numpy as np\\nimport torch\\nvideo = list(np.random.randn(16, 3, 224, 224))\\nprocessor = VideoMAEImageProcessor.from_pretrained(MCG-NJU/videomae-base-finetuned-ssv2)\\nmodel = VideoMAEForVideoClassification.from_pretrained(MCG-NJU/videomae-base-finetuned-ssv2)\\ninputs = processor(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\': 70.6, \'top-5\': 92.6}}, \'description\': \'VideoMAE model pre-trained for 2400 epochs in a self-supervised way and fine-tuned in a supervised way on Something-Something-v2. It was introduced in the paper VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training by Tong et al. and first released in this repository.\'}', metadata={})]


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


 We need to analyze the user's text for extracting entities and improve our virtual assistant interaction.\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={})]


 Extract the named entities from a given text snippet.\n###Input: \"On June 7th, Jane Smith visited the Empire State Building in New York with an entry fee of 35 dollars.\"\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={})]


 As a surveillance analyst, my main task this week is to find out all the names and locations mentioned in the online chat rooms.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Segmentation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'shi-labs/oneformer_ade20k_swin_large\', \'api_call\': "OneFormerForUniversalSegmentation.from_pretrained(\'shi-labs/oneformer_ade20k_swin_large\')", \'api_arguments\': [\'images\', \'task_inputs\', \'return_tensors\'], \'python_environment_requirements\': [\'transformers\', \'PIL\', \'requests\'], \'example_code\': \'from transformers import OneFormerProcessor, OneFormerForUniversalSegmentation\\nfrom PIL import Image\\nimport requests\\nurl = https://huggingface.co/datasets/shi-labs/oneformer_demo/blob/main/ade20k.jpeg\\nimage = Image.open(requests.get(url, stream=True).raw)\\nprocessor = OneFormerProcessor.from_pretrained(shi-labs/oneformer_ade20k_swin_large)\\nmodel = OneFormerForUniversalSegmentation.from_pretrained(shi-labs/oneformer_ade20k_swin_large)\\nsemantic_inputs = processor(images=image, task_inputs=[semantic], return_tensors=pt)\\nsemantic_outputs = model(**semantic_inputs)\\npredicted_semantic_map = processor.post_process_semantic_segmentation(outputs, target_sizes=[image.size[::-1]])[0]\', \'performance\': {\'dataset\': \'scene_parse_150\', \'accuracy\': None}, \'description\': \'OneFormer model trained on the ADE20k dataset (large-sized version, Swin backbone). It was introduced in the paper OneFormer: One Transformer to Rule Universal Image Segmentation by Jain et al. and first released in this repository. OneFormer is the first multi-task universal image segmentation framework. It needs to be trained only once with a single universal architecture, a single model, and on a single dataset, to outperform existing specialized models across semantic, instance, and panoptic segmentation tasks. OneFormer uses a task token to condition the model on the task in focus, making the architecture task-guided for training, and task-dynamic for inference, all with a single model.\'}', metadata={})]


 I need a program to identify the entities like persons, locations, organizations, and other names in a given German text.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Token Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Named Entity Recognition\', \'api_name\': \'Jean-Baptiste/camembert-ner\', \'api_call\': "AutoModelForTokenClassification.from_pretrained(\'Jean-Baptiste/camembert-ner\')", \'api_arguments\': {\'model\': \'model\', \'tokenizer\': \'tokenizer\', \'aggregation_strategy\': \'simple\'}, \'python_environment_requirements\': {\'transformers\': \'AutoTokenizer, AutoModelForTokenClassification, pipeline\'}, \'example_code\': "from transformers import AutoTokenizer, AutoModelForTokenClassification\\ntokenizer = AutoTokenizer.from_pretrained(Jean-Baptiste/camembert-ner)\\nmodel = AutoModelForTokenClassification.from_pretrained(Jean-Baptiste/camembert-ner)\\n\\nfrom transformers import pipeline\\nnlp = pipeline(\'ner\', model=model, tokenizer=tokenizer, aggregation_strategy=simple)\\nnlp(Apple est cre le 1er avril 1976 dans le garage de la maison d\'enfance de Steve Jobs  Los Altos en Californie par Steve Jobs, Steve Wozniak et Ronald Wayne14, puis constitue sous forme de socit le 3 janvier 1977  l\'origine sous le nom d\'Apple Computer, mais pour ses 30 ans et pour reflter la diversification de ses produits, le mot « computer  est retir le 9 janvier 2015.)", \'performance\': {\'dataset\': \'wikiner-fr\', \'accuracy\': {\'overall_f1\': 0.8914, \'PER_f1\': 0.9483, \'ORG_f1\': 0.8181, \'LOC_f1\': 0.8955, \'MISC_f1\': 0.8146}}, \'description\': \'camembert-ner is a Named Entity Recognition (NER) model fine-tuned from camemBERT on the wikiner-fr dataset. It can recognize entities such as persons, organizations, locations, and miscellaneous entities.\'}', metadata={})]