 A Russia-based online lesson website needs an English subtitle for the recorded lessons of the students.\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={})]


 My lecture has been recorded, and I would like to transcribe the audio to create a transcript of my presentation.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Token Classification\', \'framework\': \'Transformers\', \'functionality\': \'Named Entity Recognition\', \'api_name\': \'dslim/bert-base-NER\', \'api_call\': "AutoModelForTokenClassification.from_pretrained(\'dslim/bert-base-NER\')", \'api_arguments\': {\'model\': \'AutoModelForTokenClassification.from_pretrained(dslim/bert-base-NER)\', \'tokenizer\': \'AutoTokenizer.from_pretrained(dslim/bert-base-NER)\'}, \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'from transformers import AutoTokenizer, AutoModelForTokenClassification\\nfrom transformers import pipeline\\ntokenizer = AutoTokenizer.from_pretrained(dslim/bert-base-NER)\\nmodel = AutoModelForTokenClassification.from_pretrained(dslim/bert-base-NER)\\nnlp = pipeline(ner, model=model, tokenizer=tokenizer)\\nexample = My name is Wolfgang and I live in Berlin\\nner_results = nlp(example)\\nprint(ner_results)\', \'performance\': {\'dataset\': \'conll2003\', \'accuracy\': {\'f1\': 91.3, \'precision\': 90.7, \'recall\': 91.9}}, \'description\': \'bert-base-NER is a fine-tuned BERT model that is ready to use for Named Entity Recognition and achieves state-of-the-art performance for the NER task. It has been trained to recognize four types of entities: location (LOC), organizations (ORG), person (PER) and Miscellaneous (MISC). Specifically, this model is a bert-base-cased model that was fine-tuned on the English version of the standard CoNLL-2003 Named Entity Recognition dataset.\'}', metadata={})]


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


 We're working with a voiceover company, and they're looking for a tool to help them change the voice style of voiceovers while keeping the same content.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Image\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-Image\', \'api_name\': \'nitrosocke/nitro-diffusion\', \'api_call\': "StableDiffusionPipeline.from_pretrained(\'nitrosocke/nitro-diffusion\', torch_dtype=torch.float16)", \'api_arguments\': [\'prompt\'], \'python_environment_requirements\': [\'torch\', \'diffusers\'], \'example_code\': \'from diffusers import StableDiffusionPipeline\\nimport torch\\nmodel_id = nitrosocke/nitro-diffusion\\npipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)\\npipe = pipe.to(cuda)\\nprompt = archer arcane style magical princess with golden hair\\nimage = pipe(prompt).images[0]\\nimage.save(./magical_princess.png)\', \'performance\': {\'dataset\': \'Stable Diffusion\', \'accuracy\': \'N/A\'}, \'description\': \'Nitro Diffusion is a fine-tuned Stable Diffusion model trained on three artstyles simultaneously while keeping each style separate from the others. It allows for high control of mixing, weighting, and single style use.\'}', metadata={})]


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


 The company needs to separate voice from background noise in a recorded podcast episode.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Voice Activity Detection\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Voice Activity Detection, Overlapped Speech Detection, Resegmentation\', \'api_name\': \'pyannote/segmentation\', \'api_call\': "VoiceActivityDetection(segmentation=\'pyannote/segmentation\')", \'api_arguments\': {\'onset\': 0.5, \'offset\': 0.5, \'min_duration_on\': 0.0, \'min_duration_off\': 0.0}, \'python_environment_requirements\': \'pyannote.audio 2.0\', \'example_code\': \'from pyannote.audio.pipelines import VoiceActivityDetection\\npipeline = VoiceActivityDetection(segmentation=pyannote/segmentation)\\nHYPER_PARAMETERS = {\\n  onset: 0.5, offset: 0.5,\\n  min_duration_on: 0.0,\\n  min_duration_off: 0.0\\n}\\npipeline.instantiate(HYPER_PARAMETERS)\\nvad = pipeline(audio.wav)\', \'performance\': {\'dataset\': {\'ami\': {\'accuracy\': {\'onset\': 0.684, \'offset\': 0.577, \'min_duration_on\': 0.181, \'min_duration_off\': 0.037}}, \'dihard\': {\'accuracy\': {\'onset\': 0.767, \'offset\': 0.377, \'min_duration_on\': 0.136, \'min_duration_off\': 0.067}}, \'voxconverse\': {\'accuracy\': {\'onset\': 0.767, \'offset\': 0.713, \'min_duration_on\': 0.182, \'min_duration_off\': 0.501}}}}, \'description\': \'Model from End-to-end speaker segmentation for overlap-aware resegmentation, by Hervé Bredin and Antoine Laurent. It provides voice activity detection, overlapped speech detection, and resegmentation functionalities.\'}', metadata={})]


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


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


 I am the director of a movie theater chain, and we are thinking of implementing a chat product to get movie goers to classify movie reviews as positive or negative through AI.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Text Classification\', \'api_name\': \'lvwerra/distilbert-imdb\', \'api_call\': "pipeline(\'sentiment-analysis\', model=\'lvwerra/distilbert-imdb\')", \'api_arguments\': [], \'python_environment_requirements\': [\'transformers\', \'pytorch\'], \'example_code\': "classifier(\'I love this movie!\')", \'performance\': {\'dataset\': \'imdb\', \'accuracy\': 0.928}, \'description\': \'This model is a fine-tuned version of distilbert-base-uncased on the imdb dataset. It is used for sentiment analysis on movie reviews and achieves an accuracy of 0.928 on the evaluation set.\'}', metadata={})]


 You have been provided with the dataset of plants, and your task is to identify the species of plants among Iris Setosa, Iris Versicolor, and Iris Virginica.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Classification\', \'framework\': \'Joblib\', \'functionality\': \'Multi-class Classification\', \'api_name\': \'abhishek/autotrain-iris-xgboost\', \'api_call\': "joblib.load(\'model.joblib\')", \'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\': \'scikit-learn/iris\', \'accuracy\': 0.8666666666666667}, \'description\': \'A tabular classification model trained on the Iris dataset using XGBoost and AutoTrain. The model is capable of multi-class classification and has an accuracy of 86.67%.\'}', metadata={})]


 Our energy company is trying to identify anomalies in the energy consumption data. Could you perform anomaly detection on the time series data?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Token Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Entity Extraction\', \'api_name\': \'903429548\', \'api_call\': "AutoModelForTokenClassification.from_pretrained(\'ismail-lucifer011/autotrain-company_all-903429548\', use_auth_token=True)", \'api_arguments\': {\'inputs\': \'I love AutoTrain\'}, \'python_environment_requirements\': {\'transformers\': \'AutoModelForTokenClassification, AutoTokenizer\'}, \'example_code\': \'from transformers import AutoModelForTokenClassification, AutoTokenizer\\nmodel = AutoModelForTokenClassification.from_pretrained(ismail-lucifer011/autotrain-company_all-903429548, use_auth_token=True)\\ntokenizer = AutoTokenizer.from_pretrained(ismail-lucifer011/autotrain-company_all-903429548, use_auth_token=True)\\ninputs = tokenizer(I love AutoTrain, return_tensors=pt)\\noutputs = model(**inputs)\', \'performance\': {\'dataset\': \'ismail-lucifer011/autotrain-data-company_all\', \'accuracy\': 0.9979930566588805}, \'description\': \'A token classification model trained using AutoTrain for entity extraction. The model is based on the distilbert architecture and trained on the ismail-lucifer011/autotrain-data-company_all dataset. It can be used to identify and extract company names from text.\'}', metadata={})]


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


 Create a program that predicts carbon emissions for new data using the given model.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Regression\', \'framework\': \'Joblib\', \'functionality\': \'Carbon Emissions\', \'api_name\': \'pcoloc/autotrain-600-dragino-1839063122\', \'api_call\': "joblib.load(\'model.joblib\')", \'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\': \'pcoloc/autotrain-data-600-dragino\', \'accuracy\': {\'Loss\': 93.595, \'R2\': 0.502, \'MSE\': 8760.052, \'MAE\': 77.527, \'RMSLE\': 0.445}}, \'description\': \'This model is trained to perform single column regression on carbon emissions data using the AutoTrain framework. It predicts CO2 emissions in grams given the input data.\'}', metadata={})]


 A company has collected data about fish measurements and weights. We need to estimate a fish's weight based on its measurements.\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 company manages a restaurant. We need to analyze customers' tips and predict how much tip a new customer would give based on their total bill, sex, smoker, day, time, and party size. We should use a pre-trained model.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'hyunwoongko/blenderbot-9B\', \'api_call\': "pipeline(\'conversational\', model=\'hyunwoongko/blenderbot-9B\')", \'api_arguments\': \'text\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'Input a message to start chatting with hyunwoongko/blenderbot-9B.\', \'performance\': {\'dataset\': \'blended_skill_talk\', \'accuracy\': \'Not provided\'}, \'description\': \'Building open-domain chatbots is a challenging area for machine learning research. While prior work has shown that scaling neural models in the number of parameters and the size of the data they are trained on gives improved results, we show that other ingredients are important for a high-performing chatbot. Good conversation requires a number of skills that an expert conversationalist blends in a seamless way: providing engaging talking points and listening to their partners, both asking and answering questions, and displaying knowledge, empathy and personality appropriately, depending on the situation. We show that large scale models can learn these skills when given appropriate training data and choice of generation strategy. We build variants of these recipes with 90M, 2.7B and 9.4B parameter neural models, and make our models and code publicly available. Human evaluations show our best models are superior to existing approaches in multi-turn dialogue in terms of engagingness and humanness measurements. We then discuss the limitations of this work by analyzing failure cases of our models.\'}', metadata={})]


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


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


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


 A product is built that analyzes book reviews in order to determine how similar two examples from multiple books are to each other.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'results-yelp\', \'api_call\': "AutoTokenizer.from_pretrained(\'bert-base-uncased\')", \'api_arguments\': {\'tokenizer\': "AutoTokenizer.from_pretrained(\'bert-base-uncased\')", \'config\': "AutoConfig.from_pretrained(\'potatobunny/results-yelp\')"}, \'python_environment_requirements\': {\'Transformers\': \'4.18.0\', \'Pytorch\': \'1.10.0+cu111\', \'Datasets\': \'2.0.0\', \'Tokenizers\': \'0.12.1\'}, \'example_code\': \'\', \'performance\': {\'dataset\': \'Yelp\', \'accuracy\': 0.9302}, \'description\': \'This model is a fine-tuned version of textattack/bert-base-uncased-yelp-polarity on a filtered and manually reviewed Yelp dataset containing restaurant reviews only. It is intended to perform text classification, specifically sentiment analysis, on text data obtained from restaurant reviews to determine if the particular review is positive or negative.\'}', metadata={})]


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


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


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


The marketing department wants to use AI-generated images for their next social media campaign. They want a high-resolution image of a vintage sports car racing through a desert landscape during sunset. \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={})]


 My company is working on a children's storybook. I need to generate images based on the text descriptions of scenes in the story.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Image\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-Image\', \'api_name\': \'wavymulder/Analog-Diffusion\', \'api_call\': "pipeline(\'text-to-image\', model=\'wavymulder/Analog-Diffusion\')", \'api_arguments\': [\'prompt\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': "text_to_image(\'analog style landscape\')", \'performance\': {\'dataset\': \'analog photographs\', \'accuracy\': \'Not specified\'}, \'description\': "Analog Diffusion is a dreambooth model trained on a diverse set of analog photographs. It can generate images based on text prompts with an analog style. Use the activation token \'analog style\' in your prompt to get the desired output. The model is available on the Hugging Face Inference API and can be used with the transformers library."}', metadata={})]


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


 I am designing an e-commerce website, and I want a program to generate images based on written descriptions to be used as mock product images.\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={})]


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


 We are building a visual tour guide application for smartphones. The app should be able to identify landmarks and provide information about them. I want to use the BLIP-2 model for this task.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'text-generation\', \'api_name\': \'pygmalion-2.7b\', \'api_call\': "pipeline(\'text-generation\', model=\'PygmalionAI/pygmalion-2.7b\')", \'api_arguments\': {\'input_prompt\': \'string\'}, \'python_environment_requirements\': {\'transformers\': \'latest\'}, \'example_code\': "model([CHARACTER]\'s Persona: [A few sentences about the character you want the model to play]<START>[DIALOGUE HISTORY]You: [Your input message here][CHARACTER]:)", \'performance\': {\'dataset\': \'56MB of dialogue data\', \'accuracy\': \'N/A\'}, \'description\': "Pygmalion 2.7B is a proof-of-concept dialogue model based on EleutherAI\'s gpt-neo-2.7B. It is fine-tuned on 56MB of dialogue data gathered from multiple sources, including real and partially machine-generated conversations. The model is intended for use in generating conversational responses and can be used with a specific input format that includes character persona, dialogue history, and user input message."}', metadata={})]


 I need a tool to analyze a chart image and generate a summary of the information contained within the chart.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Image-to-Text\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'google/deplot\', \'api_call\': "Pix2StructForConditionalGeneration.from_pretrained(\'google/deplot\')", \'api_arguments\': {\'images\': \'image\', \'text\': \'question\', \'return_tensors\': \'pt\', \'max_new_tokens\': 512}, \'python_environment_requirements\': {\'transformers\': \'Pix2StructForConditionalGeneration, Pix2StructProcessor\', \'requests\': \'requests\', \'PIL\': \'Image\'}, \'example_code\': "from transformers import Pix2StructForConditionalGeneration, Pix2StructProcessor\\nimport requests\\nfrom PIL import Image\\nmodel = Pix2StructForConditionalGeneration.from_pretrained(\'google/deplot\')\\nprocessor = Pix2StructProcessor.from_pretrained(\'google/deplot\')\\nurl = https://raw.githubusercontent.com/vis-nlp/ChartQA/main/ChartQA%20Dataset/val/png/5090.png\\nimage = Image.open(requests.get(url, stream=True).raw)\\ninputs = processor(images=image, text=Generate underlying data table of the figure below:, return_tensors=pt)\\npredictions = model.generate(**inputs, max_new_tokens=512)\\nprint(processor.decode(predictions[0], skip_special_tokens=True))", \'performance\': {\'dataset\': \'ChartQA\', \'accuracy\': \'24.0% improvement over finetuned SOTA\'}, \'description\': \'DePlot is a model that translates the image of a plot or chart to a linearized table. It decomposes the challenge of visual language reasoning into two steps: (1) plot-to-text translation, and (2) reasoning over the translated text. The output of DePlot can then be directly used to prompt a pretrained large language model (LLM), exploiting the few-shot reasoning capabilities of LLMs.\'}', metadata={})]


 Generate a video for a cooking show intro with the text \"Chef John's Culinary Adventures.\"\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Video\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-Video\', \'api_name\': \'camenduru/text2-video-zero\', \'api_call\': "pipeline(\'text-to-video\', model=\'camenduru/text2-video-zero\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'\', \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'This model is used for generating videos from text inputs. It is based on the Hugging Face framework and can be used with the transformers library. The model is trained on a variety of text and video datasets, and can be used for tasks such as video summarization, video generation from text prompts, and more.\'}', metadata={})]


 We are doing a creative commercial. We require a video that represents a person walking along a beach.\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={})]


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


 We have an online journal application that requires users to upload documents in which we need to automatically answer the questions related to the uploaded 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={})]


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


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


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


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


 I want to classify the images of houseplants to find out their type, like whether it's a cactus, fern, or succulent.\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 have few picture from my album, and I would like to find out whether it is a hotdog or not.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Transformers\', \'functionality\': \'Sentence Correction\', \'api_name\': \'flexudy/t5-base-multi-sentence-doctor\', \'api_call\': "AutoModelWithLMHead.from_pretrained(\'flexudy/t5-base-multi-sentence-doctor\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'from transformers import AutoTokenizer, AutoModelWithLMHead\\ntokenizer = AutoTokenizer.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\nmodel = AutoModelWithLMHead.from_pretrained(flexudy/t5-base-multi-sentence-doctor)\\ninput_text = repair_sentence: m a medical doct context: {That is my job I a}{or I save lives} </s>\\ninput_ids = tokenizer.encode(input_text, return_tensors=pt)\\noutputs = model.generate(input_ids, max_length=32, num_beams=1)\\nsentence = tokenizer.decode(outputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)\\nassert sentence == I am a medical doctor.\', \'performance\': {\'dataset\': \'tatoeba\', \'accuracy\': \'Not specified\'}, \'description\': \'Sentence doctor is a T5 model that attempts to correct the errors or mistakes found in sentences. Model works on English, German and French text.\'}', metadata={})]


 Our client is building an application that converts scanned tables into structured data. We need to detect the rows and columns in a given table 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={})]


 I am hosting a vegan food event and I want to know if any of the dishes contains meat from the picture I have taken.\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={})]


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


 We need to segment clothes in photos for our online fashion store.\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={})]


 Automate the process of creating a normal map from a given object image.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Automatic Speech Recognition\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'facebook/wav2vec2-xlsr-53-espeak-cv-ft\', \'api_call\': "Wav2Vec2ForCTC.from_pretrained(\'facebook/wav2vec2-xlsr-53-espeak-cv-ft\')", \'api_arguments\': {\'model_name\': \'facebook/wav2vec2-xlsr-53-espeak-cv-ft\'}, \'python_environment_requirements\': {\'transformers\': \'4.13.0\', \'torch\': \'1.10.0\', \'datasets\': \'1.14.0\'}, \'example_code\': \'processor = Wav2Vec2Processor.from_pretrained(facebook/wav2vec2-xlsr-53-espeak-cv-ft)\\nmodel = Wav2Vec2ForCTC.from_pretrained(facebook/wav2vec2-xlsr-53-espeak-cv-ft)\\nds = load_dataset(patrickvonplaten/librispeech_asr_dummy, clean, split=validation)\\ninput_values = processor(ds[0][audio][array], return_tensors=pt).input_values\\nwith torch.no_grad():\\n    logits = model(input_values).logits\\npredicted_ids = torch.argmax(logits, dim=-1)\\ntranscription = processor.batch_decode(predicted_ids)\', \'performance\': {\'dataset\': \'common_voice\', \'accuracy\': \'Not specified\'}, \'description\': \'Wav2Vec2-Large-XLSR-53 finetuned on multi-lingual Common Voice for phonetic label recognition in multiple languages. The model outputs a string of phonetic labels, and a dictionary mapping phonetic labels to words has to be used to map the phonetic output labels to output words.\'}', metadata={})]


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


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


 A creative artist wants to generate a painting from a given input text titled \"A head full of roses,\" utilizing the image provided in the API description.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Table Question Answering\', \'framework\': \'Transformers\', \'functionality\': \'Table Question Answering\', \'api_name\': \'google/tapas-base-finetuned-wikisql-supervised\', \'api_call\': "TapasForQuestionAnswering.from_pretrained(\'google/tapas-base-finetuned-wikisql-supervised\')", \'api_arguments\': [\'question\', \'table\'], \'python_environment_requirements\': [\'PyTorch\', \'TensorFlow\'], \'example_code\': \'This model can be loaded on the Inference API on-demand.\', \'performance\': {\'dataset\': \'wikisql\', \'accuracy\': \'Not provided\'}, \'description\': \'TAPAS is a BERT-like transformers model pretrained on a large corpus of English data from Wikipedia in a self-supervised fashion. It was pretrained with two objectives: Masked language modeling (MLM) and Intermediate pre-training. Fine-tuning is done by adding a cell selection head and aggregation head on top of the pre-trained model, and then jointly train these randomly initialized classification heads with the base model on SQA and WikiSQL.\'}', metadata={})]


 I would like to generate a high-quality image of a church using unconditional image generation.\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={})]


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


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


 Can you teach me to build a program that will analyze video and describe what's happening in natural language?\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={})]


 In a security context, the company is starting a project to detect any signs of violence in video streams from its CCTV cameras. It's essential to analyze the video content for any violent behaviors.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'emotion\', \'api_name\': \'bhadresh-savani/distilbert-base-uncased-emotion\', \'api_call\': "pipeline(\'text-classification\', model=\'bhadresh-savani/distilbert-base-uncased-emotion\', return_all_scores=True)", \'api_arguments\': [\'text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': "prediction = classifier(\'I love using transformers. The best part is wide range of support and its easy to use\')", \'performance\': {\'dataset\': \'Twitter-Sentiment-Analysis\', \'accuracy\': 0.938}, \'description\': "Distilbert is created with knowledge distillation during the pre-training phase which reduces the size of a BERT model by 40%, while retaining 97% of its language understanding. It\'s smaller, faster than Bert and any other Bert-based model. Distilbert-base-uncased finetuned on the emotion dataset using HuggingFace Trainer."}', metadata={})]


 Create a sports highlight generator that takes video clips as input and identifies the category of the sports activity happening in the video.\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={})]


 I am a movie director and I need to detect the genre of a movie based on its actions.\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={})]