 We are creating an online video conference service, and we need to detect when two or more speakers are speaking at the same time in the audio.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Voice Activity Detection\', \'framework\': \'pyannote.audio\', \'functionality\': \'Speaker diarization\', \'api_name\': \'johnislarry/cloned-pyannote-speaker-diarization-endpoint\', \'api_call\': "Pipeline.from_pretrained(\'pyannote/speaker-diarization@2.1\',use_auth_token=\'ACCESS_TOKEN_GOES_HERE\')", \'api_arguments\': [\'num_speakers\', \'min_speakers\', \'max_speakers\', \'segmentation_onset\'], \'python_environment_requirements\': \'pyannote.audio 2.0\', \'example_code\': {\'load_pipeline\': \'from pyannote.audio import Pipeline\\npipeline = Pipeline.from_pretrained(pyannote/speaker-diarization@2022.07)\', \'apply_pipeline\': \'diarization = pipeline(audio.wav)\', \'save_output\': \'with open(audio.rttm, w) as rttm:\\n  diarization.write_rttm(rttm)\'}, \'performance\': {\'dataset\': [{\'name\': \'AISHELL-4\', \'accuracy\': {\'DER%\': 14.61, \'FA%\': 3.31, \'Miss%\': 4.35, \'Conf%\': 6.95}}, {\'name\': \'AMI Mix-Headset only_words\', \'accuracy\': {\'DER%\': 18.21, \'FA%\': 3.28, \'Miss%\': 11.07, \'Conf%\': 3.87}}, {\'name\': \'AMI Array1-01 only_words\', \'accuracy\': {\'DER%\': 29.0, \'FA%\': 2.71, \'Miss%\': 21.61, \'Conf%\': 4.68}}, {\'name\': \'CALLHOME Part2\', \'accuracy\': {\'DER%\': 30.24, \'FA%\': 3.71, \'Miss%\': 16.86, \'Conf%\': 9.66}}, {\'name\': \'DIHARD 3 Full\', \'accuracy\': {\'DER%\': 20.99, \'FA%\': 4.25, \'Miss%\': 10.74, \'Conf%\': 6.0}}, {\'name\': \'REPERE Phase 2\', \'accuracy\': {\'DER%\': 12.62, \'FA%\': 1.55, \'Miss%\': 3.3, \'Conf%\': 7.76}}, {\'name\': \'VoxConverse v0.0.2\', \'accuracy\': {\'DER%\': 12.76, \'FA%\': 3.45, \'Miss%\': 3.85, \'Conf%\': 5.46}}]}, \'description\': \'This API provides speaker diarization functionality using the pyannote.audio framework. It is capable of processing audio files and outputting speaker diarization results in RTTM format. The API supports providing the number of speakers, minimum and maximum number of speakers, and adjusting the segmentation onset threshold.\'}', metadata={})]


 Our company develops smart speaker devices that involve interaction with the user. We need to transcribe the input from the users with the maintained accent or language.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Text-to-Speech\', \'framework\': \'ESPnet\', \'functionality\': \'Text-to-Speech\', \'api_name\': \'SYSPIN/Telugu_Male_TTS\', \'api_call\': "pipeline(\'text-to-speech\', model=\'SYSPIN/Telugu_Male_TTS\')", \'api_arguments\': [\'text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'\', \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'A Telugu Male Text-to-Speech model using the ESPnet framework, provided by Hugging Face.\'}', metadata={})]


 One of our clients is facing noise issues on their audio recordings. Can you help them to remove the noise from the audio?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Voice Activity Detection\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Voice Activity Detection, Speech-to-Noise Ratio, and C50 Room Acoustics Estimation\', \'api_name\': \'pyannote/brouhaha\', \'api_call\': "Model.from_pretrained(\'pyannote/brouhaha\', use_auth_token=\'ACCESS_TOKEN_GOES_HERE\')", \'api_arguments\': [\'audio.wav\'], \'python_environment_requirements\': [\'pyannote-audio\', \'brouhaha-vad\'], \'example_code\': [\'from pyannote.audio import Model\', \'model = Model.from_pretrained(pyannote/brouhaha, use_auth_token=ACCESS_TOKEN_GOES_HERE)\', \'from pyannote.audio import Inference\', \'inference = Inference(model)\', \'output = inference(audio.wav)\', \'for frame, (vad, snr, c50) in output:\', \'  t = frame.middle\', \'  print(f{t:8.3f} vad={100*vad:.0f}% snr={snr:.0f} c50={c50:.0f})\'], \'performance\': {\'dataset\': \'LibriSpeech, AudioSet, EchoThief, MIT-Acoustical-Reverberation-Scene\', \'accuracy\': \'Not provided\'}, \'description\': \'Brouhaha is a joint voice activity detection, speech-to-noise ratio, and C50 room acoustics estimation model. It is based on the PyTorch framework and uses the pyannote.audio library.\'}', metadata={})]


 We are a media company and we have a large volume of Chinese language audio files. We want to transcribe the audios into chinese text.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Automatic Speech Recognition\', \'framework\': \'CTranslate2\', \'functionality\': \'Automatic Speech Recognition\', \'api_name\': \'guillaumekln/faster-whisper-large-v2\', \'api_call\': "WhisperModel(\'large-v2\')", \'api_arguments\': [\'audio.mp3\'], \'python_environment_requirements\': [\'faster_whisper\'], \'example_code\': \'from faster_whisper import WhisperModel\\nmodel = WhisperModel(large-v2)\\nsegments, info = model.transcribe(audio.mp3)\\nfor segment in segments:\\n print([%.2fs -> %.2fs] %s % (segment.start, segment.end, segment.text))\', \'performance\': {\'dataset\': \'99 languages\', \'accuracy\': \'Not provided\'}, \'description\': \'Whisper large-v2 model for CTranslate2. This model can be used in CTranslate2 or projets based on CTranslate2 such as faster-whisper.\'}', metadata={})]


 Help us improve the listener experience from our customers by enhancing the audio of noisy recordings.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Voice Activity Detection\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Voice Activity Detection, Speech-to-Noise Ratio, and C50 Room Acoustics Estimation\', \'api_name\': \'pyannote/brouhaha\', \'api_call\': "Model.from_pretrained(\'pyannote/brouhaha\', use_auth_token=\'ACCESS_TOKEN_GOES_HERE\')", \'api_arguments\': [\'audio.wav\'], \'python_environment_requirements\': [\'pyannote-audio\', \'brouhaha-vad\'], \'example_code\': [\'from pyannote.audio import Model\', \'model = Model.from_pretrained(pyannote/brouhaha, use_auth_token=ACCESS_TOKEN_GOES_HERE)\', \'from pyannote.audio import Inference\', \'inference = Inference(model)\', \'output = inference(audio.wav)\', \'for frame, (vad, snr, c50) in output:\', \'  t = frame.middle\', \'  print(f{t:8.3f} vad={100*vad:.0f}% snr={snr:.0f} c50={c50:.0f})\'], \'performance\': {\'dataset\': \'LibriSpeech, AudioSet, EchoThief, MIT-Acoustical-Reverberation-Scene\', \'accuracy\': \'Not provided\'}, \'description\': \'Brouhaha is a joint voice activity detection, speech-to-noise ratio, and C50 room acoustics estimation model. It is based on the PyTorch framework and uses the pyannote.audio library.\'}', metadata={})]


 Our company is working on a project to automatically translate spoken English audio to spoken Hokkien audio. We need a speech-to-speech translation model.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Text-to-Speech\', \'framework\': \'Fairseq\', \'functionality\': \'Text-to-Speech\', \'api_name\': \'unit_hifigan_HK_layer12.km2500_frame_TAT-TTS\', \'api_call\': "load_model_ensemble_and_task_from_hf_hub(\'facebook/unit_hifigan_HK_layer12.km2500_frame_TAT-TT\')", \'api_arguments\': {\'unit\': \'Text input for the TTS model\'}, \'python_environment_requirements\': [\'fairseq\', \'huggingface_hub\', \'torchaudio\'], \'example_code\': "import json\\nimport os\\nfrom pathlib import Path\\nimport IPython.display as ipd\\nfrom fairseq import hub_utils\\nfrom fairseq.checkpoint_utils import load_model_ensemble_and_task_from_hf_hub\\nfrom fairseq.models.speech_to_text.hub_interface import S2THubInterface\\nfrom fairseq.models.text_to_speech import CodeHiFiGANVocoder\\nfrom fairseq.models.text_to_speech.hub_interface import VocoderHubInterface\\nfrom huggingface_hub import snapshot_download\\nimport torchaudio\\ncache_dir = os.getenv(HUGGINGFACE_HUB_CACHE)\\nlibrary_name = fairseq\\ncache_dir = (\\n cache_dir or (Path.home() / .cache / library_name).as_posix()\\n)\\ncache_dir = snapshot_download(\\n ffacebook/unit_hifigan_HK_layer12.km2500_frame_TAT-TTS, cache_dir=cache_dir, library_name=library_name\\n)\\nx = hub_utils.from_pretrained(\\n cache_dir,\\n model.pt,\\n .,\\n archive_map=CodeHiFiGANVocoder.hub_models(),\\n config_yaml=config.json,\\n fp16=False,\\n is_vocoder=True,\\n)\\nwith open(f{x[\'args\'][\'data\']}/config.json) as f:\\n vocoder_cfg = json.load(f)\\nassert (\\n len(x[args][model_path]) == 1\\n), Too many vocoder models in the input\\nvocoder = CodeHiFiGANVocoder(x[args][model_path][0], vocoder_cfg)\\ntts_model = VocoderHubInterface(vocoder_cfg, vocoder)\\ntts_sample = tts_model.get_model_input(unit)\\nwav, sr = tts_model.get_prediction(tts_sample)\\nipd.Audio(wav, rate=sr)", \'performance\': {\'dataset\': \'TAT-TTS\', \'accuracy\': \'Not provided\'}, \'description\': \'Hokkien unit HiFiGAN based vocoder from fairseq. Trained with TAT-TTS data with 4 speakers in Taiwanese Hokkien accent.\'}', metadata={})]


 We are a startup developing voice assistants. We need a keyword spotting system that can recognize user commands.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Voice Activity Detection\', \'framework\': \'Hugging Face\', \'functionality\': \'Voice Activity Detection\', \'api_name\': \'d4data/Indian-voice-cloning\', \'api_call\': "pipeline(\'voice-activity-detection\', model=\'d4data/Indian-voice-cloning\')", \'api_arguments\': [], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'\', \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'A model for detecting voice activity in Indian languages.\'}', metadata={})]


 The model needs to have speech recognition capability to identify languages in a given audio file.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Automatic Speech Recognition\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Speech Recognition\', \'api_name\': \'jonatasgrosman/wav2vec2-large-xlsr-53-portuguese\', \'api_call\': "SpeechRecognitionModel(\'jonatasgrosman/wav2vec2-large-xlsr-53-portuguese\')", \'api_arguments\': [\'audio_paths\'], \'python_environment_requirements\': [\'huggingsound\', \'torch\', \'librosa\', \'datasets\', \'transformers\'], \'example_code\': \'from huggingsound import SpeechRecognitionModel\\nmodel = SpeechRecognitionModel(jonatasgrosman/wav2vec2-large-xlsr-53-portuguese)\\naudio_paths = [/path/to/file.mp3, /path/to/another_file.wav]\\ntranscriptions = model.transcribe(audio_paths)\', \'performance\': {\'dataset\': \'mozilla-foundation/common_voice_6_0\', \'accuracy\': {\'Test WER\': 11.31, \'Test CER\': 3.74, \'Test WER (+LM)\': 9.01, \'Test CER (+LM)\': 3.21}}, \'description\': \'Fine-tuned facebook/wav2vec2-large-xlsr-53 on Portuguese using the train and validation splits of Common Voice 6.1. When using this model, make sure that your speech input is sampled at 16kHz.\'}', metadata={})]


 I have just recorded a meeting, I want to find the best segments from the audio where people are speaking, and construct a summary.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Audio Voice Activity Detection\', \'framework\': \'pyannote.audio\', \'functionality\': \'Speaker diarization\', \'api_name\': \'johnislarry/cloned-pyannote-speaker-diarization-endpoint\', \'api_call\': "Pipeline.from_pretrained(\'pyannote/speaker-diarization@2.1\',use_auth_token=\'ACCESS_TOKEN_GOES_HERE\')", \'api_arguments\': [\'num_speakers\', \'min_speakers\', \'max_speakers\', \'segmentation_onset\'], \'python_environment_requirements\': \'pyannote.audio 2.0\', \'example_code\': {\'load_pipeline\': \'from pyannote.audio import Pipeline\\npipeline = Pipeline.from_pretrained(pyannote/speaker-diarization@2022.07)\', \'apply_pipeline\': \'diarization = pipeline(audio.wav)\', \'save_output\': \'with open(audio.rttm, w) as rttm:\\n  diarization.write_rttm(rttm)\'}, \'performance\': {\'dataset\': [{\'name\': \'AISHELL-4\', \'accuracy\': {\'DER%\': 14.61, \'FA%\': 3.31, \'Miss%\': 4.35, \'Conf%\': 6.95}}, {\'name\': \'AMI Mix-Headset only_words\', \'accuracy\': {\'DER%\': 18.21, \'FA%\': 3.28, \'Miss%\': 11.07, \'Conf%\': 3.87}}, {\'name\': \'AMI Array1-01 only_words\', \'accuracy\': {\'DER%\': 29.0, \'FA%\': 2.71, \'Miss%\': 21.61, \'Conf%\': 4.68}}, {\'name\': \'CALLHOME Part2\', \'accuracy\': {\'DER%\': 30.24, \'FA%\': 3.71, \'Miss%\': 16.86, \'Conf%\': 9.66}}, {\'name\': \'DIHARD 3 Full\', \'accuracy\': {\'DER%\': 20.99, \'FA%\': 4.25, \'Miss%\': 10.74, \'Conf%\': 6.0}}, {\'name\': \'REPERE Phase 2\', \'accuracy\': {\'DER%\': 12.62, \'FA%\': 1.55, \'Miss%\': 3.3, \'Conf%\': 7.76}}, {\'name\': \'VoxConverse v0.0.2\', \'accuracy\': {\'DER%\': 12.76, \'FA%\': 3.45, \'Miss%\': 3.85, \'Conf%\': 5.46}}]}, \'description\': \'This API provides speaker diarization functionality using the pyannote.audio framework. It is capable of processing audio files and outputting speaker diarization results in RTTM format. The API supports providing the number of speakers, minimum and maximum number of speakers, and adjusting the segmentation onset threshold.\'}', metadata={})]


 I am running a wine store, and I am looking for a machine learning model that can help me classify the quality of wine based on some given features.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Classification\', \'framework\': \'Scikit-learn\', \'functionality\': \'Wine Quality classification\', \'api_name\': \'julien-c/wine-quality\', \'api_call\': "joblib.load(cached_download(hf_hub_url(\'julien-c/wine-quality\', \'winequality-red.csv\')))", \'api_arguments\': [\'X\'], \'python_environment_requirements\': [\'huggingface_hub\', \'joblib\', \'pandas\'], \'example_code\': \'from huggingface_hub import hf_hub_url, cached_download\\nimport joblib\\nimport pandas as pd\\nREPO_ID = julien-c/wine-quality\\nFILENAME = sklearn_model.joblib\\nmodel = joblib.load(cached_download(\\n hf_hub_url(REPO_ID, FILENAME)\\n))\\ndata_file = cached_download(\\n hf_hub_url(REPO_ID, winequality-red.csv)\\n)\\nwinedf = pd.read_csv(data_file, sep=;)\\nX = winedf.drop([quality], axis=1)\\nY = winedf[quality]\\nprint(X[:3])\\nlabels = model.predict(X[:3])\\nmodel.score(X, Y)\', \'performance\': {\'dataset\': \'julien-c/wine-quality\', \'accuracy\': 0.6616635397123202}, \'description\': \'A Simple Example of Scikit-learn Pipeline for Wine Quality classification. Inspired by https://towardsdatascience.com/a-simple-example-of-pipeline-in-machine-learning-with-scikit-learn-e726ffbb6976 by Saptashwa Bhattacharyya.\'}', metadata={})]


 Build a simple application to predict the survival status of passengers on the Titanic based on their age, gender, and passenger class.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Classification\', \'framework\': \'Scikit-learn\', \'functionality\': \'Binary Classification\', \'api_name\': \'danupurnomo/dummy-titanic\', \'api_call\': "load_model(cached_download(hf_hub_url(\'danupurnomo/dummy-titanic\', \'titanic_model.h5\')))", \'api_arguments\': [\'new_data\'], \'python_environment_requirements\': [\'huggingface_hub\', \'joblib\', \'pandas\', \'numpy\', \'tensorflow\'], \'example_code\': "from huggingface_hub import hf_hub_url, cached_download\\nimport joblib\\nimport pandas as pd\\nimport numpy as np\\nfrom tensorflow.keras.models import load_model\\nREPO_ID = \'danupurnomo/dummy-titanic\'\\nPIPELINE_FILENAME = \'final_pipeline.pkl\'\\nTF_FILENAME = \'titanic_model.h5\'\\nmodel_pipeline = joblib.load(cached_download(\\n hf_hub_url(REPO_ID, PIPELINE_FILENAME)\\n))\\nmodel_seq = load_model(cached_download(\\n hf_hub_url(REPO_ID, TF_FILENAME)\\n))", \'performance\': {\'dataset\': \'Titanic\', \'accuracy\': \'Not provided\'}, \'description\': \'This model is a binary classifier for predicting whether a passenger on the Titanic survived or not, based on features such as passenger class, age, sex, fare, and more.\'}', metadata={})]


 I need to estimate CO2 emissions from vehicles based on their characteristics, such as engine size, transmission type, and miles traveled.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Regression\', \'framework\': \'Hugging Face\', \'functionality\': \'Carbon Emissions\', \'api_name\': \'kochetkovIT/autotrain-ironhack-49741119788\', \'api_call\': "joblib.load(\'model.joblib\')", \'api_arguments\': [\'data\'], \'python_environment_requirements\': [\'json\', \'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\': \'kochetkovIT/autotrain-data-ironhack\', \'accuracy\': {\'Loss\': 2.603, \'R2\': 0.013, \'MSE\': 6.776, \'MAE\': 1.666, \'RMSLE\': 0.502}}, \'description\': \'A tabular regression model trained using AutoTrain to predict carbon emissions (in grams) with an R2 score of 0.013.\'}', metadata={})]


 We have been asked to predict future criminal re-offense from a given dataset. What model should we adopt and how do we proceed?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Classification\', \'framework\': \'Scikit-learn\', \'functionality\': \'Classification\', \'api_name\': \'imodels/figs-compas-recidivism\', \'api_call\': "joblib.load(cached_download(hf_hub_url(\'imodels/figs-compas-recidivism\', \'sklearn_model.joblib\')))", \'api_arguments\': [\'REPO_ID\', \'FILENAME\'], \'python_environment_requirements\': [\'joblib\', \'huggingface_hub\', \'pandas\', \'numpy\', \'datasets\', \'imodels\', \'sklearn.model_selection\'], \'example_code\': "from huggingface_hub import hf_hub_url, cached_download\\nimport joblib\\nimport pandas as pd\\nREPO_ID = imodels/figs-compas-recidivism\\nFILENAME = sklearn_model.joblib\\nmodel = joblib.load(cached_download(\\n hf_hub_url(REPO_ID, FILENAME)\\n))\\npreds = model.predict(X_test)\\nprint(\'accuracy\', np.mean(preds==y_test))", \'performance\': {\'dataset\': \'imodels/compas-recidivism\', \'accuracy\': 0.6759165485112416}, \'description\': \'A tabular classification model for predicting recidivism using the COMPAS dataset. The model is an imodels.FIGSClassifier trained with Scikit-learn and can be used with the Hugging Face Inference API.\'}', metadata={})]


 Our company's goal is to predict carbon emissions based on the given features of the compound.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Regression\', \'framework\': \'Hugging Face\', \'functionality\': \'Carbon Emissions\', \'api_name\': \'kochetkovIT/autotrain-ironhack-49741119788\', \'api_call\': "joblib.load(\'model.joblib\')", \'api_arguments\': [\'data\'], \'python_environment_requirements\': [\'json\', \'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\': \'kochetkovIT/autotrain-data-ironhack\', \'accuracy\': {\'Loss\': 2.603, \'R2\': 0.013, \'MSE\': 6.776, \'MAE\': 1.666, \'RMSLE\': 0.502}}, \'description\': \'A tabular regression model trained using AutoTrain to predict carbon emissions (in grams) with an R2 score of 0.013.\'}', metadata={})]


 The factory wants to make its production process more eco-friendly. Calculate the carbon emissions for given data.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Regression\', \'framework\': \'Hugging Face\', \'functionality\': \'Carbon Emissions\', \'api_name\': \'45473113800\', \'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\': \'samvelkoch/autotrain-data-prknsn-2\', \'accuracy\': {\'Loss\': 5.079, \'R2\': 0.109, \'MSE\': 25.795, \'MAE\': 3.78, \'RMSLE\': 0.849}}, \'description\': \'A tabular regression model trained with AutoTrain for predicting carbon emissions.\'}', metadata={})]


 We want to predict the carbon emissions of a new line of electric vehicles for an annual report. Automate the process of loading a regression model, then calculate the forecast of emissions for this year.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Regression\', \'framework\': \'Hugging Face\', \'functionality\': \'Carbon Emissions\', \'api_name\': \'kochetkovIT/autotrain-ironhack-49741119788\', \'api_call\': "joblib.load(\'model.joblib\')", \'api_arguments\': [\'data\'], \'python_environment_requirements\': [\'json\', \'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\': \'kochetkovIT/autotrain-data-ironhack\', \'accuracy\': {\'Loss\': 2.603, \'R2\': 0.013, \'MSE\': 6.776, \'MAE\': 1.666, \'RMSLE\': 0.502}}, \'description\': \'A tabular regression model trained using AutoTrain to predict carbon emissions (in grams) with an R2 score of 0.013.\'}', metadata={})]


 We are planning to launch a website which provides tips to people for their daily lives. Can you please build a model to predict the appropriate amount of tips?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Tabular Tabular Regression\', \'framework\': \'Scikit-learn\', \'functionality\': \'baseline-trainer\', \'api_name\': \'merve/tips9y0jvt5q-tip-regression\', \'api_call\': "pipeline(\'tabular-regression\', model=\'merve/tips9y0jvt5q-tip-regression\')", \'api_arguments\': \'N/A\', \'python_environment_requirements\': \'dabl\', \'example_code\': \'N/A\', \'performance\': {\'dataset\': \'tips9y0jvt5q\', \'accuracy\': {\'r2\': 0.41524, \'neg_mean_squared_error\': -1.098792}}, \'description\': \'Baseline Model trained on tips9y0jvt5q to apply regression on tip. The model uses Ridge(alpha=10) and is trained with dabl library as a baseline. For better results, use AutoTrain.\'}', metadata={})]


 We have a robotic arm in our warehouse that needs to be trained to optimize loading and unloading tasks. The robotic arm is based on the CartPole environment.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Reinforcement Learning\', \'framework\': \'Stable-Baselines3\', \'functionality\': \'CartPole-v1\', \'api_name\': \'dqn-CartPole-v1\', \'api_call\': "load_from_hub(repo_id=\'sb3/dqn-CartPole-v1\',filename=\'{MODEL FILENAME}.zip\',)", \'api_arguments\': [\'algo\', \'env\', \'logs\'], \'python_environment_requirements\': [\'rl_zoo3\', \'stable-baselines3\', \'stable-baselines3-contrib\'], \'example_code\': \'python train.py --algo dqn --env CartPole-v1 -f logs/\', \'performance\': {\'dataset\': \'CartPole-v1\', \'accuracy\': \'500.00 +/- 0.00\'}, \'description\': \'This is a trained model of a DQN agent playing CartPole-v1 using the stable-baselines3 library and the RL Zoo. The RL Zoo is a training framework for Stable Baselines3 reinforcement learning agents, with hyperparameter optimization and pre-trained agents included.\'}', metadata={})]


 There is an upcoming event called \"Space Party\" and we need a representative image for the event. Can you assist us in creating an image containing a party in space with astronauts and aliens having fun together?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Image\', \'framework\': \'Hugging Face\', \'functionality\': \'Text-to-Image\', \'api_name\': \'prompthero/openjourney-v4\', \'api_call\': "pipeline(\'text-to-image\', model=\'prompthero/openjourney-v4\')", \'api_arguments\': {\'text\': \'string\'}, \'python_environment_requirements\': [\'transformers\'], \'example_code\': "generate_image(\'your text here\')", \'performance\': {\'dataset\': \'Midjourney v4 images\', \'accuracy\': \'Not provided\'}, \'description\': \'Openjourney v4 is trained on +124k Midjourney v4 images by PromptHero. It is used for generating images based on text inputs.\'}', metadata={})]


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


 We have a collection of low-resolution images of movie characters, and we need to upscale those images to get a more detailed high-resolution image.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Text-to-Image\', \'framework\': \'Hugging Face\', \'functionality\': \'Image Upscaling\', \'api_name\': \'stabilityai/sd-x2-latent-upscaler\', \'api_call\': \'StableDiffusionLatentUpscalePipeline.from_pretrained(stabilityai/sd-x2-latent-upscaler, torch_dtype=torch.float16)\', \'api_arguments\': {\'prompt\': \'text prompt\', \'image\': \'low resolution latents\', \'num_inference_steps\': 20, \'guidance_scale\': 0, \'generator\': \'torch generator\'}, \'python_environment_requirements\': [\'git+https://github.com/huggingface/diffusers.git\', \'transformers\', \'accelerate\', \'scipy\', \'safetensors\'], \'example_code\': \'from diffusers import StableDiffusionLatentUpscalePipeline, StableDiffusionPipeline\\nimport torch\\npipeline = StableDiffusionPipeline.from_pretrained(CompVis/stable-diffusion-v1-4, torch_dtype=torch.float16)\\npipeline.to(cuda)\\nupscaler = StableDiffusionLatentUpscalePipeline.from_pretrained(stabilityai/sd-x2-latent-upscaler, torch_dtype=torch.float16)\\nupscaler.to(cuda)\\nprompt = a photo of an astronaut high resolution, unreal engine, ultra realistic\\ngenerator = torch.manual_seed(33)\\nlow_res_latents = pipeline(prompt, generator=generator, output_type=latent).images\\nupscaled_image = upscaler(prompt=prompt, image=low_res_latents, num_inference_steps=20, guidance_scale=0, generator=generator).images[0]\\nupscaled_image.save(astronaut_1024.png)\', \'performance\': {\'dataset\': \'LAION-2B\', \'accuracy\': \'Not specified\'}, \'description\': "Stable Diffusion x2 latent upscaler is a diffusion-based upscaler model developed by Katherine Crowson in collaboration with Stability AI. It is designed to upscale Stable Diffusion\'s latent denoised image embeddings, allowing for fast text-to-image and upscaling pipelines. The model was trained on a high-resolution subset of the LAION-2B dataset and works with all Stable Diffusion checkpoints."}', metadata={})]


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


 We need a tool to help us generate textual descriptions for images and videos related to our product.\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 need to build an AI-powered tool to assist visually impaired users in understanding their surroundings by answering questions about images.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Visual Question Answering\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Visual Question Answering\', \'api_name\': \'temp_vilt_vqa\', \'api_call\': "pipeline(\'visual-question-answering\', model=\'Bingsu/temp_vilt_vqa\', tokenizer=\'Bingsu/temp_vilt_vqa\')", \'api_arguments\': {\'model\': \'Bingsu/temp_vilt_vqa\', \'tokenizer\': \'Bingsu/temp_vilt_vqa\'}, \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'A visual question answering model for answering questions related to images using the Hugging Face Transformers library.\'}', metadata={})]


 I'm a nutritionist and want to help my clients by answering questions about their meals. They will send me an image of their food and ask me a question about it, like \"Is this vegan?\" or \"How many calories do you think it contains?\"\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Document Question Answer\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'vision-encoder-decoder\', \'api_name\': \'naver-clova-ix/donut-base-finetuned-docvqa\', \'api_call\': "pipeline(\'document-question-answering\', model=\'donut-base-finetuned-docvqa\')", \'api_arguments\': {\'image\': \'path_to_image\', \'question\': \'your_question\'}, \'python_environment_requirements\': \'Transformers\', \'example_code\': "from transformers import pipeline\\n\\n# Initialize the pipeline\\ndoc_qa = pipeline(\'document-question-answering\', model=\'naver-clova-ix/donut-base-finetuned-docvqa\')\\n\\n# Load an image and ask a question\\nimage_path = \'path_to_image\'\\nquestion = \'your_question\'\\n\\n# Get the answer\\nanswer = doc_qa({\'image\': image_path, \'question\': question})\\nprint(answer)", \'performance\': {\'dataset\': \'DocVQA\', \'accuracy\': \'Not provided\'}, \'description\': \'Donut model fine-tuned on DocVQA. It was introduced in the paper OCR-free Document Understanding Transformer by Geewok et al. and first released in this repository. Donut consists of a vision encoder (Swin Transformer) and a text decoder (BART). Given an image, the encoder first encodes the image into a tensor of embeddings (of shape batch_size, seq_len, hidden_size), after which the decoder autoregressively generates text, conditioned on the encoding of the encoder.\'}', metadata={})]


 Our client is a legal firm that needs assistance in extracting specific information from a large number of legal documents. Automate the process of answering questions related to these documents.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Document Question Answer\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Document Question Answering\', \'api_name\': \'CQI_Visual_Question_Awnser_PT_v0\', \'api_call\': "pipeline(\'question-answering\', model=LayoutLMForQuestionAnswering.from_pretrained(\'microsoft/layoutlm-base-uncased\'))", \'api_arguments\': [\'url\', \'question\'], \'python_environment_requirements\': [\'PIL\', \'pytesseract\', \'PyTorch\', \'transformers\'], \'example_code\': ["nlp(\'https://templates.invoicehome.com/invoice-template-us-neat-750px.png\', \'What is the invoice number?\')", "nlp(\'https://miro.medium.com/max/787/1*iECQRIiOGTmEFLdWkVIH2g.jpeg\', \'What is the purchase amount?\')", "nlp(\'https://www.accountingcoach.com/wp-content/uploads/2013/10/income-statement-example@2x.png\', \'What are the 2020 net sales?\')"], \'performance\': {\'dataset\': [{\'accuracy\': 0.9943977}, {\'accuracy\': 0.9912159}, {\'accuracy\': 0.59147286}]}, \'description\': \'A model for visual question answering in Portuguese and English, capable of processing PDFs and images to extract information and answer questions.\'}', metadata={})]


 In a healthcare company, we are trying to create an automated system for answering patient-related questions based on their medical documents. We need a solution using NLP.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Question Answering\', \'framework\': \'Transformers\', \'functionality\': \'Question Answering\', \'api_name\': \'deepset/roberta-base-squad2-covid\', \'api_call\': "pipeline(\'question-answering\', model=RobertaForQuestionAnswering.from_pretrained(\'deepset/roberta-base-squad2-covid\'), tokenizer=RobertaTokenizer.from_pretrained(\'deepset/roberta-base-squad2-covid\'))", \'api_arguments\': {\'model_name\': \'deepset/roberta-base-squad2-covid\', \'tokenizer\': \'deepset/roberta-base-squad2-covid\'}, \'python_environment_requirements\': [\'transformers\'], \'example_code\': {\'QA_input\': {\'question\': \'Why is model conversion important?\', \'context\': \'The option to convert models between FARM and transformers gives freedom to the user and let people easily switch between frameworks.\'}, \'res\': \'nlp(QA_input)\'}, \'performance\': {\'dataset\': \'squad_v2\', \'accuracy\': {\'XVAL_EM\': 0.17890995260663506, \'XVAL_f1\': 0.49925444207319924, \'XVAL_top_3_recall\': 0.8021327014218009}}, \'description\': \'This model is a Roberta-based model fine-tuned on SQuAD-style CORD-19 annotations for the task of extractive question answering in the context of COVID-19. It can be used with the Hugging Face Transformers library for question answering tasks.\'}', metadata={})]


 Develop a program which can answer questions related to a scanned document.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Document Question Answer\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Document Question Answering\', \'api_name\': \'CQI_Visual_Question_Awnser_PT_v0\', \'api_call\': "pipeline(\'question-answering\', model=LayoutLMForQuestionAnswering.from_pretrained(\'microsoft/layoutlm-base-uncased\'))", \'api_arguments\': [\'url\', \'question\'], \'python_environment_requirements\': [\'PIL\', \'pytesseract\', \'PyTorch\', \'transformers\'], \'example_code\': ["nlp(\'https://templates.invoicehome.com/invoice-template-us-neat-750px.png\', \'What is the invoice number?\')", "nlp(\'https://miro.medium.com/max/787/1*iECQRIiOGTmEFLdWkVIH2g.jpeg\', \'What is the purchase amount?\')", "nlp(\'https://www.accountingcoach.com/wp-content/uploads/2013/10/income-statement-example@2x.png\', \'What are the 2020 net sales?\')"], \'performance\': {\'dataset\': [{\'accuracy\': 0.9943977}, {\'accuracy\': 0.9912159}, {\'accuracy\': 0.59147286}]}, \'description\': \'A model for visual question answering in Portuguese and English, capable of processing PDFs and images to extract information and answer questions.\'}', metadata={})]


 I have received a PDF document and a question. My task is to find the answer part in the document.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Document Question Answer\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Document Question Answering\', \'api_name\': \'CQI_Visual_Question_Awnser_PT_v0\', \'api_call\': "pipeline(\'question-answering\', model=LayoutLMForQuestionAnswering.from_pretrained(\'microsoft/layoutlm-base-uncased\'))", \'api_arguments\': [\'url\', \'question\'], \'python_environment_requirements\': [\'PIL\', \'pytesseract\', \'PyTorch\', \'transformers\'], \'example_code\': ["nlp(\'https://templates.invoicehome.com/invoice-template-us-neat-750px.png\', \'What is the invoice number?\')", "nlp(\'https://miro.medium.com/max/787/1*iECQRIiOGTmEFLdWkVIH2g.jpeg\', \'What is the purchase amount?\')", "nlp(\'https://www.accountingcoach.com/wp-content/uploads/2013/10/income-statement-example@2x.png\', \'What are the 2020 net sales?\')"], \'performance\': {\'dataset\': [{\'accuracy\': 0.9943977}, {\'accuracy\': 0.9912159}, {\'accuracy\': 0.59147286}]}, \'description\': \'A model for visual question answering in Portuguese and English, capable of processing PDFs and images to extract information and answer questions.\'}', metadata={})]


 An interior design firm builds a software to understand the depth of rooms captured in photographs for remodeling activities.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Unconditional Image Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Denoising Diffusion Probabilistic Models (DDPM)\', \'api_name\': \'google/ddpm-bedroom-256\', \'api_call\': "DDPMPipeline.from_pretrained(\'google/ddpm-bedroom-256\')", \'api_arguments\': \'None\', \'python_environment_requirements\': \'diffusers\', \'example_code\': \'!pip install diffusers\\nfrom diffusers import DDPMPipeline, DDIMPipeline, PNDMPipeline\\nmodel_id = google/ddpm-bedroom-256\\nddpm = DDPMPipeline.from_pretrained(model_id)\\nimage = ddpm().images[0]\\nimage.save(ddpm_generated_image.png)\', \'performance\': {\'dataset\': \'CIFAR10\', \'accuracy\': {\'Inception score\': 9.46, \'FID score\': 3.17}}, \'description\': \'We present high quality image synthesis results using diffusion probabilistic models, a class of latent variable models inspired by considerations from nonequilibrium thermodynamics. Our best results are obtained by training on a weighted variational bound designed according to a novel connection between diffusion probabilistic models and denoising score matching with Langevin dynamics, and our models naturally admit a progressive lossy decompression scheme that can be interpreted as a generalization of autoregressive decoding. On the unconditional CIFAR10 dataset, we obtain an Inception score of 9.46 and a state-of-the-art FID score of 3.17. On 256x256 LSUN, we obtain sample quality similar to ProgressiveGAN.\'}', metadata={})]


 We are running an autonomous vehicle company and want to implement a depth estimation module for the real-time video feed captured by our camera.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Depth Estimation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Depth Estimation\', \'api_name\': \'glpn-kitti\', \'api_call\': "GLPNForDepthEstimation.from_pretrained(\'vinvino02/glpn-kitti\')", \'api_arguments\': \'images, return_tensors\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'from transformers import GLPNFeatureExtractor, GLPNForDepthEstimation\\nimport torch\\nimport numpy as np\\nfrom PIL import Image\\nimport requests\\nurl = http://images.cocodataset.org/val2017/000000039769.jpg\\nimage = Image.open(requests.get(url, stream=True).raw)\\nfeature_extractor = GLPNFeatureExtractor.from_pretrained(vinvino02/glpn-kitti)\\nmodel = GLPNForDepthEstimation.from_pretrained(vinvino02/glpn-kitti)\\ninputs = feature_extractor(images=image, return_tensors=pt)\\nwith torch.no_grad():\\n outputs = model(**inputs)\\n predicted_depth = outputs.predicted_depth\\nprediction = torch.nn.functional.interpolate(\\n predicted_depth.unsqueeze(1),\\n size=image.size[::-1],\\n mode=bicubic,\\n align_corners=False,\\n)\\noutput = prediction.squeeze().cpu().numpy()\\nformatted = (output * 255 / np.max(output)).astype(uint8)\\ndepth = Image.fromarray(formatted)\', \'performance\': {\'dataset\': \'KITTI\', \'accuracy\': \'Not provided\'}, \'description\': \'Global-Local Path Networks (GLPN) model trained on KITTI for monocular depth estimation. It was introduced in the paper Global-Local Path Networks for Monocular Depth Estimation with Vertical CutDepth by Kim et al. and first released in this repository.\'}', metadata={})]


 Our team wants to create a new app for autonomous vehicles. For that, we need to estimate the depth of the field from images.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Depth Estimation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Depth Estimation\', \'api_name\': \'glpn-kitti\', \'api_call\': "GLPNForDepthEstimation.from_pretrained(\'vinvino02/glpn-kitti\')", \'api_arguments\': \'images, return_tensors\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'from transformers import GLPNFeatureExtractor, GLPNForDepthEstimation\\nimport torch\\nimport numpy as np\\nfrom PIL import Image\\nimport requests\\nurl = http://images.cocodataset.org/val2017/000000039769.jpg\\nimage = Image.open(requests.get(url, stream=True).raw)\\nfeature_extractor = GLPNFeatureExtractor.from_pretrained(vinvino02/glpn-kitti)\\nmodel = GLPNForDepthEstimation.from_pretrained(vinvino02/glpn-kitti)\\ninputs = feature_extractor(images=image, return_tensors=pt)\\nwith torch.no_grad():\\n outputs = model(**inputs)\\n predicted_depth = outputs.predicted_depth\\nprediction = torch.nn.functional.interpolate(\\n predicted_depth.unsqueeze(1),\\n size=image.size[::-1],\\n mode=bicubic,\\n align_corners=False,\\n)\\noutput = prediction.squeeze().cpu().numpy()\\nformatted = (output * 255 / np.max(output)).astype(uint8)\\ndepth = Image.fromarray(formatted)\', \'performance\': {\'dataset\': \'KITTI\', \'accuracy\': \'Not provided\'}, \'description\': \'Global-Local Path Networks (GLPN) model trained on KITTI for monocular depth estimation. It was introduced in the paper Global-Local Path Networks for Monocular Depth Estimation with Vertical CutDepth by Kim et al. and first released in this repository.\'}', metadata={})]


 As a city planner, I need to measure the depth of spaces in a series of images taken from streets.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Depth Estimation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Depth Estimation\', \'api_name\': \'glpn-nyu-finetuned-diode\', \'api_call\': "pipeline(\'depth-estimation\', model=\'sayakpaul/glpn-nyu-finetuned-diode\')", \'api_arguments\': [], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'\', \'performance\': {\'dataset\': \'diode-subset\', \'accuracy\': {\'Loss\': 0.4359, \'Rmse\': 0.4276}}, \'description\': \'This model is a fine-tuned version of vinvino02/glpn-nyu on the diode-subset dataset.\'}', metadata={})]


 In our online ecommerce platform, we want to build an AI app to automatically recognize the type of products. It should be able to identify common items like clothing, electronics, furniture, and more.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Image Classification\', \'api_name\': \'abhishek/autotrain-dog-vs-food\', \'api_call\': "pipeline(\'image-classification\', model=\'abhishek/autotrain-dog-vs-food\')", \'api_arguments\': \'image_path\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'sasha/dog-food\', \'accuracy\': 0.998}, \'description\': "A pre-trained model for classifying images as either dog or food using Hugging Face\'s AutoTrain framework."}', metadata={})]


 We need to recognize the breed of dog in the given image.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Image Classification\', \'api_name\': \'julien-c/hotdog-not-hotdog\', \'api_call\': "pipeline(\'image-classification\', model=\'julien-c/hotdog-not-hotdog\')", \'api_arguments\': \'image\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'\', \'accuracy\': 0.825}, \'description\': \'A model that classifies images as hotdog or not hotdog.\'}', metadata={})]


 Develop a solution that can categorize an image of a cell phone, laptop, or smartwatch as one of these respective device types.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Image Classification\', \'api_name\': \'julien-c/hotdog-not-hotdog\', \'api_call\': "pipeline(\'image-classification\', model=\'julien-c/hotdog-not-hotdog\')", \'api_arguments\': \'image\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'\', \'accuracy\': 0.825}, \'description\': \'A model that classifies images as hotdog or not hotdog.\'}', metadata={})]


 Build a system to help companies identify logos from a collection of images.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Zero-Shot Image Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Zero-Shot Image Classification\', \'api_name\': \'patrickjohncyh/fashion-clip\', \'api_call\': "CLIPModel.from_pretrained(\'patrickjohncyh/fashion-clip\')", \'api_arguments\': {\'image\': \'File\', \'class_names\': \'String (comma-separated)\'}, \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import CLIPProcessor, CLIPModel; model = CLIPModel.from_pretrained(\'patrickjohncyh/fashion-clip\'); processor = CLIPProcessor.from_pretrained(\'patrickjohncyh/fashion-clip\'); inputs = processor(text=\'blue shoes\', images=image, return_tensors=\'pt\', padding=True); logits_per_image = model(**inputs).logits_per_image; probs = logits_per_image.softmax(dim=-1).tolist()[0]", \'performance\': {\'dataset\': [{\'name\': \'FMNIST\', \'accuracy\': 0.83}, {\'name\': \'KAGL\', \'accuracy\': 0.73}, {\'name\': \'DEEP\', \'accuracy\': 0.62}]}, \'description\': \'FashionCLIP is a CLIP-based model developed to produce general product representations for fashion concepts. Leveraging the pre-trained checkpoint (ViT-B/32) released by OpenAI, it is trained on a large, high-quality novel fashion dataset to study whether domain specific fine-tuning of CLIP-like models is sufficient to produce product representations that are zero-shot transferable to entirely new datasets and tasks.\'}', metadata={})]


 Develop a pipeline that detects objects present in an image using computer vision.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Object Detection\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'microsoft/table-transformer-structure-recognition\', \'api_call\': "pipeline(\'object-detection\', model=\'microsoft/table-transformer-structure-recognition\')", \'api_arguments\': \'\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'PubTables1M\', \'accuracy\': \'\'}, \'description\': \'Table Transformer (DETR) model trained on PubTables1M for detecting the structure (like rows, columns) in tables.\'}', metadata={})]


 Assit me to process and segment an image for further analysis.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Segmentation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Image Segmentation\', \'api_name\': \'keremberke/yolov8m-pcb-defect-segmentation\', \'api_call\': "YOLO(\'keremberke/yolov8m-pcb-defect-segmentation\')", \'api_arguments\': {\'image\': \'URL or local path to the image\'}, \'python_environment_requirements\': [\'ultralyticsplus==0.0.24\', \'ultralytics==8.0.23\'], \'example_code\': [\'from ultralyticsplus import YOLO, render_result\', "model = YOLO(\'keremberke/yolov8m-pcb-defect-segmentation\')", "model.overrides[\'conf\'] = 0.25", "model.overrides[\'iou\'] = 0.45", "model.overrides[\'agnostic_nms\'] = False", "model.overrides[\'max_det\'] = 1000", "image = \'https://github.com/ultralytics/yolov5/raw/master/data/images/zidane.jpg\'", \'results = model.predict(image)\', \'print(results[0].boxes)\', \'print(results[0].masks)\', \'render = render_result(model=model, image=image, result=results[0])\', \'render.show()\'], \'performance\': {\'dataset\': \'pcb-defect-segmentation\', \'accuracy\': {\'mAP@0.5(box)\': 0.568, \'mAP@0.5(mask)\': 0.557}}, \'description\': \'A YOLOv8 model for PCB defect segmentation trained on the pcb-defect-segmentation dataset. The model can detect and segment defects in PCB images, such as Dry_joint, Incorrect_installation, PCB_damage, and Short_circuit.\'}', metadata={})]


 We need to analyze satellite images to categorize the types of land use. For this purpose, I need to segment the images and identify different objects.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Segmentation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Image Segmentation\', \'api_name\': \'keremberke/yolov8s-building-segmentation\', \'api_call\': "YOLO(\'keremberke/yolov8s-building-segmentation\')", \'api_arguments\': [\'conf\', \'iou\', \'agnostic_nms\', \'max_det\', \'image\'], \'python_environment_requirements\': [\'ultralyticsplus==0.0.21\'], \'example_code\': [\'from ultralyticsplus import YOLO, render_result\', "model = YOLO(\'keremberke/yolov8s-building-segmentation\')", "model.overrides[\'conf\'] = 0.25", "model.overrides[\'iou\'] = 0.45", "model.overrides[\'agnostic_nms\'] = False", "model.overrides[\'max_det\'] = 1000", "image = \'https://github.com/ultralytics/yolov5/raw/master/data/images/zidane.jpg\'", \'results = model.predict(image)\', \'print(results[0].boxes)\', \'print(results[0].masks)\', \'render = render_result(model=model, image=image, result=results[0])\', \'render.show()\'], \'performance\': {\'dataset\': \'satellite-building-segmentation\', \'accuracy\': {\'mAP@0.5(box)\': 0.661, \'mAP@0.5(mask)\': 0.651}}, \'description\': \'A YOLOv8 model for building segmentation in satellite images. Trained on the satellite-building-segmentation dataset, it can detect and segment buildings with high accuracy.\'}', metadata={})]


 We are a city planning department and want to evaluate the city layout. Analyze the image we provide to segment and understand the various urban elements.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Segmentation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Semantic Segmentation\', \'api_name\': \'nvidia/segformer-b2-finetuned-cityscapes-1024-1024\', \'api_call\': "SegformerForSemanticSegmentation.from_pretrained(\'nvidia/segformer-b2-finetuned-cityscapes-1024-1024\')", \'api_arguments\': {\'images\': \'image\', \'return_tensors\': \'pt\'}, \'python_environment_requirements\': {\'transformers\': \'latest\', \'PIL\': \'latest\', \'requests\': \'latest\'}, \'example_code\': "from transformers import SegformerFeatureExtractor, SegformerForSemanticSegmentation\\nfrom PIL import Image\\nimport requests\\nfeature_extractor = SegformerFeatureExtractor.from_pretrained(\'nvidia/segformer-b2-finetuned-cityscapes-1024-1024\')\\nmodel = SegformerForSemanticSegmentation.from_pretrained(\'nvidia/segformer-b2-finetuned-cityscapes-1024-1024\')\\nurl = \'http://images.cocodataset.org/val2017/000000039769.jpg\'\\nimage = Image.open(requests.get(url, stream=True).raw)\\ninputs = feature_extractor(images=image, return_tensors=\'pt\')\\noutputs = model(**inputs)\\nlogits = outputs.logits", \'performance\': {\'dataset\': \'Cityscapes\', \'accuracy\': \'Not provided\'}, \'description\': \'SegFormer model fine-tuned on CityScapes at resolution 1024x1024. It was introduced in the paper SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers by Xie et al. and first released in this repository.\'}', metadata={})]


 My company develops drones for agriculture purposes, and we need a model to segment aerial images accurately.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Segmentation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Transformers\', \'api_name\': \'clipseg-rd64-refined\', \'api_call\': "pipeline(\'image-segmentation\', model=\'CIDAS/clipseg-rd64-refined\')", \'api_arguments\': {\'model\': \'CIDAS/clipseg-rd64-refined\'}, \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'CLIPSeg model with reduce dimension 64, refined (using a more complex convolution). It was introduced in the paper Image Segmentation Using Text and Image Prompts by Lüddecke et al. and first released in this repository. This model is intended for zero-shot and one-shot image segmentation.\'}', metadata={})]


 I want to generate images from text descriptions and use the scribble images as control inputs for my project.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image-to-Image\', \'framework\': \'Diffusers\', \'functionality\': \'Text-to-Image\', \'api_name\': \'lllyasviel/control_v11p_sd15_scribble\', \'api_call\': "ControlNetModel.from_pretrained(\'lllyasviel/control_v11p_sd15_scribble\')", \'api_arguments\': {\'checkpoint\': \'lllyasviel/control_v11p_sd15_scribble\', \'torch_dtype\': \'torch.float16\'}, \'python_environment_requirements\': [\'diffusers\', \'transformers\', \'accelerate\', \'controlnet_aux==0.3.0\'], \'example_code\': "import torch\\nimport os\\nfrom huggingface_hub import HfApi\\nfrom pathlib import Path\\nfrom diffusers.utils import load_image\\nfrom PIL import Image\\nimport numpy as np\\nfrom controlnet_aux import PidiNetDetector, HEDdetector\\nfrom diffusers import (\\n ControlNetModel,\\n StableDiffusionControlNetPipeline,\\n UniPCMultistepScheduler,\\n)\\ncheckpoint = lllyasviel/control_v11p_sd15_scribble\\nimage = load_image(\\n https://huggingface.co/lllyasviel/control_v11p_sd15_scribble/resolve/main/images/input.png\\n)\\nprompt = royal chamber with fancy bed\\nprocessor = HEDdetector.from_pretrained(\'lllyasviel/Annotators\')\\ncontrol_image = processor(image, scribble=True)\\ncontrol_image.save(./images/control.png)\\ncontrolnet = ControlNetModel.from_pretrained(checkpoint, torch_dtype=torch.float16)\\npipe = StableDiffusionControlNetPipeline.from_pretrained(\\n runwayml/stable-diffusion-v1-5, controlnet=controlnet, torch_dtype=torch.float16\\n)\\npipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)\\npipe.enable_model_cpu_offload()\\ngenerator = torch.manual_seed(0)\\nimage = pipe(prompt, num_inference_steps=30, generator=generator, image=control_image).images[0]\\nimage.save(\'images/image_out.png\')", \'performance\': {\'dataset\': \'Stable Diffusion v1-5\', \'accuracy\': \'Not specified\'}, \'description\': \'Controlnet v1.1 is a neural network structure to control diffusion models by adding extra conditions. This checkpoint corresponds to the ControlNet conditioned on Scribble images. It can be used in combination with Stable Diffusion, such as runwayml/stable-diffusion-v1-5.\'}', metadata={})]


 We want to recommend workouts to our users, based on the type of sports they enjoy. Help us classify sports videos.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Video Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Video Classification\', \'api_name\': \'MCG-NJU/videomae-base-short-finetuned-kinetics\', \'api_call\': "VideoMAEForVideoClassification.from_pretrained(\'MCG-NJU/videomae-base-short-finetuned-kinetics\')", \'api_arguments\': [\'video\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import VideoMAEImageProcessor, VideoMAEForVideoClassification\\nimport numpy as np\\nimport torch\\nvideo = list(np.random.randn(16, 3, 224, 224))\\nprocessor = VideoMAEImageProcessor.from_pretrained(\'MCG-NJU/videomae-base-short-finetuned-kinetics\')\\nmodel = VideoMAEForVideoClassification.from_pretrained(\'MCG-NJU/videomae-base-short-finetuned-kinetics\')\\ninputs = processor(video, return_tensors=\'pt\')\\nwith torch.no_grad():\\n outputs = model(**inputs)\\n logits = outputs.logits\\npredicted_class_idx = logits.argmax(-1).item()\\nprint(\'Predicted class:\', model.config.id2label[predicted_class_idx])", \'performance\': {\'dataset\': \'Kinetics-400\', \'accuracy\': {\'top-1\': 79.4, \'top-5\': 94.1}}, \'description\': \'VideoMAE model pre-trained for 800 epochs in a self-supervised way and fine-tuned in a supervised way on Kinetics-400. It was introduced in the paper VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training by Tong et al. and first released in this repository.\'}', metadata={})]


 We need to classify videos showing different actions for our new video moderation system.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Video Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Video Classification\', \'api_name\': \'MCG-NJU/videomae-base-short-finetuned-kinetics\', \'api_call\': "VideoMAEForVideoClassification.from_pretrained(\'MCG-NJU/videomae-base-short-finetuned-kinetics\')", \'api_arguments\': [\'video\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import VideoMAEImageProcessor, VideoMAEForVideoClassification\\nimport numpy as np\\nimport torch\\nvideo = list(np.random.randn(16, 3, 224, 224))\\nprocessor = VideoMAEImageProcessor.from_pretrained(\'MCG-NJU/videomae-base-short-finetuned-kinetics\')\\nmodel = VideoMAEForVideoClassification.from_pretrained(\'MCG-NJU/videomae-base-short-finetuned-kinetics\')\\ninputs = processor(video, return_tensors=\'pt\')\\nwith torch.no_grad():\\n outputs = model(**inputs)\\n logits = outputs.logits\\npredicted_class_idx = logits.argmax(-1).item()\\nprint(\'Predicted class:\', model.config.id2label[predicted_class_idx])", \'performance\': {\'dataset\': \'Kinetics-400\', \'accuracy\': {\'top-1\': 79.4, \'top-5\': 94.1}}, \'description\': \'VideoMAE model pre-trained for 800 epochs in a self-supervised way and fine-tuned in a supervised way on Kinetics-400. It was introduced in the paper VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training by Tong et al. and first released in this repository.\'}', metadata={})]


 I need the AI to tell if an image is of a cat or a dog, regardless of its breed or species.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Image Classification\', \'api_name\': \'abhishek/autotrain-dog-vs-food\', \'api_call\': "pipeline(\'image-classification\', model=\'abhishek/autotrain-dog-vs-food\')", \'api_arguments\': \'image_path\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'sasha/dog-food\', \'accuracy\': 0.998}, \'description\': "A pre-trained model for classifying images as either dog or food using Hugging Face\'s AutoTrain framework."}', metadata={})]


 We have a set of pictures for pets (dogs and cats). We need to offer an AI-based solution to classify the pictures given the pet name.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Image Classification\', \'api_name\': \'abhishek/autotrain-dog-vs-food\', \'api_call\': "pipeline(\'image-classification\', model=\'abhishek/autotrain-dog-vs-food\')", \'api_arguments\': \'image_path\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'sasha/dog-food\', \'accuracy\': 0.998}, \'description\': "A pre-trained model for classifying images as either dog or food using Hugging Face\'s AutoTrain framework."}', metadata={})]


 Our startup team is now building an app for diagnosing plant diseases based on images. We need to get the diagnosis for different types of plant issues.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Computer Vision Image Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Image Classification\', \'api_name\': \'martinezomg/vit-base-patch16-224-diabetic-retinopathy\', \'api_call\': "pipeline(\'image-classification\', \'martinezomg/vit-base-patch16-224-diabetic-retinopathy\')", \'api_arguments\': {\'model_name\': \'martinezomg/vit-base-patch16-224-diabetic-retinopathy\'}, \'python_environment_requirements\': {\'transformers\': \'4.28.1\', \'pytorch\': \'2.0.0+cu118\', \'datasets\': \'2.11.0\', \'tokenizers\': \'0.13.3\'}, \'example_code\': "from transformers import pipeline\\nimage_classifier = pipeline(\'image-classification\', \'martinezomg/vit-base-patch16-224-diabetic-retinopathy\')\\nresult = image_classifier(\'path/to/image.jpg\')", \'performance\': {\'dataset\': \'None\', \'accuracy\': 0.7744}, \'description\': \'This model is a fine-tuned version of google/vit-base-patch16-224 on the None dataset. It is designed for image classification tasks, specifically for diabetic retinopathy detection.\'}', metadata={})]


 We need to analyze customer reviews and find out how well our new product is doing in the market.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Transformers\', \'functionality\': \'Sentiment Analysis\', \'api_name\': \'michellejieli/NSFW_text_classifier\', \'api_call\': "pipeline(\'sentiment-analysis\', model=\'michellejieli/NSFW_text_classification\')", \'api_arguments\': [\'text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'classifier(I see you’ve set aside this special time to humiliate yourself in public.)\', \'performance\': {\'dataset\': \'Reddit posts\', \'accuracy\': \'Not specified\'}, \'description\': \'DistilBERT is a transformer model that performs sentiment analysis. I fine-tuned the model on Reddit posts with the purpose of classifying not safe for work (NSFW) content, specifically text that is considered inappropriate and unprofessional. The model predicts 2 classes, which are NSFW or safe for work (SFW). The model is a fine-tuned version of DistilBERT. It was fine-tuned on 14317 Reddit posts pulled from the Reddit API.\'}', metadata={})]


 A new tutoring company is founded, and they want a tutoring AI. To do so, they need help in creating better explanations for a chemistry concept.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Text Generation\', \'api_name\': \'mywateriswet/ShuanBot\', \'api_call\': "pipeline(\'conversational\', model=\'mywateriswet/ShuanBot\')", \'api_arguments\': \'message\', \'python_environment_requirements\': \'transformers\', \'example_code\': "response = chatbot(\'What is your name?\')", \'performance\': {\'dataset\': \'N/A\', \'accuracy\': \'N/A\'}, \'description\': \'ShuanBot is a conversational chatbot model based on the GPT-2 architecture. It can be used for generating human-like responses in a chat context.\'}', metadata={})]


 Create a function that can determine if a given text is a question or a statement.\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\': \'shahrukhx01/question-vs-statement-classifier\', \'api_call\': "AutoModelForSequenceClassification.from_pretrained(\'shahrukhx01/question-vs-statement-classifier\')", \'api_arguments\': {\'tokenizer\': \'AutoTokenizer.from_pretrained(shahrukhx01/question-vs-statement-classifier)\'}, \'python_environment_requirements\': {\'transformers\': \'from transformers import AutoTokenizer, AutoModelForSequenceClassification\'}, \'example_code\': \'tokenizer = AutoTokenizer.from_pretrained(shahrukhx01/question-vs-statement-classifier)\\nmodel = AutoModelForSequenceClassification.from_pretrained(shahrukhx01/question-vs-statement-classifier)\', \'performance\': {\'dataset\': \'Haystack\', \'accuracy\': \'Not provided\'}, \'description\': \'Trained to add the feature for classifying queries between Question Query vs Statement Query using classification in Haystack\'}', metadata={})]


 I want to create a system that can answer questions by sorting out possible answers to a question.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Question Answering\', \'framework\': \'Transformers\', \'functionality\': \'Question Answering\', \'api_name\': \'distilbert-base-uncased-distilled-squad\', \'api_call\': "pipeline(\'question-answering\', model=\'distilbert-base-uncased-distilled-squad\')", \'api_arguments\': [\'question\', \'context\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': "from transformers import pipeline\\nquestion_answerer = pipeline(question-answering, model=\'distilbert-base-uncased-distilled-squad\')\\ncontext = r\\n... Extractive Question Answering is the task of extracting an answer from a text given a question. An example of a\\n... question answering dataset is the SQuAD dataset, which is entirely based on that task. If you would like to fine-tune\\n... a model on a SQuAD task, you may leverage the examples/pytorch/question-answering/run_squad.py script.\\n... \\nresult = question_answerer(question=What is a good example of a question answering dataset?, context=context)\\nprint(\\n... fAnswer: \'{result[\'answer\']}\', score: {round(result[\'score\'], 4)}, start: {result[\'start\']}, end: {result[\'end\']}\\n...)", \'performance\': {\'dataset\': \'SQuAD v1.1\', \'accuracy\': \'86.9 F1 score\'}, \'description\': "DistilBERT base uncased distilled SQuAD is a fine-tuned version of DistilBERT-base-uncased for the task of question answering. It has 40% less parameters than bert-base-uncased, runs 60% faster while preserving over 95% of BERT\'s performances as measured on the GLUE language understanding benchmark."}', metadata={})]


 We have a news article and we need to extract all the entities like the names of people, organizations, and locations.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Token Classification\', \'framework\': \'Transformers\', \'functionality\': \'Named Entity Recognition\', \'api_name\': \'dslim/bert-base-NER-uncased\', \'api_call\': "pipeline(\'ner\', model=\'dslim/bert-base-NER-uncased\')", \'api_arguments\': {}, \'python_environment_requirements\': {\'transformers\': \'>=4.0.0\'}, \'example_code\': "nlp(\'My name is John and I live in New York.\')", \'performance\': {\'dataset\': \'\', \'accuracy\': \'\'}, \'description\': \'A pretrained BERT model for Named Entity Recognition (NER) on uncased text. It can be used to extract entities such as person names, locations, and organizations from text.\'}', metadata={})]


 We are purchasing a CRM system to keep track of our customers and their organizations. We want to extract useful entities from customer emails automatically.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Text Generation\', \'api_name\': \'mywateriswet/ShuanBot\', \'api_call\': "pipeline(\'conversational\', model=\'mywateriswet/ShuanBot\')", \'api_arguments\': \'message\', \'python_environment_requirements\': \'transformers\', \'example_code\': "response = chatbot(\'What is your name?\')", \'performance\': {\'dataset\': \'N/A\', \'accuracy\': \'N/A\'}, \'description\': \'ShuanBot is a conversational chatbot model based on the GPT-2 architecture. It can be used for generating human-like responses in a chat context.\'}', metadata={})]


 As a researcher, I am trying to find an answer to my question in a table containing information about animals and their characteristics.\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-small-finetuned-sqa\', \'api_call\': "pipeline(\'table-question-answering\', model=\'google/tapas-small-finetuned-sqa\')", \'api_arguments\': \'\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'msr_sqa\', \'accuracy\': 0.6155}, \'description\': \'TAPAS small model fine-tuned on Sequential Question Answering (SQA). It uses relative position embeddings (i.e. resetting the position index at every cell of the table).\'}', metadata={})]


 A teacher wants to create a quiz for her students. We are now working on the questions and answers for the quiz that be arranged in a table format.\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-small-finetuned-sqa\', \'api_call\': "pipeline(\'table-question-answering\', model=\'google/tapas-small-finetuned-sqa\')", \'api_arguments\': \'\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'msr_sqa\', \'accuracy\': 0.6155}, \'description\': \'TAPAS small model fine-tuned on Sequential Question Answering (SQA). It uses relative position embeddings (i.e. resetting the position index at every cell of the table).\'}', metadata={})]


 I work for a financial company that stores all of its data in tables. We need a way to extract key information efficiently by asking natural language questions.\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-small-finetuned-sqa\', \'api_call\': "pipeline(\'table-question-answering\', model=\'google/tapas-small-finetuned-sqa\')", \'api_arguments\': \'\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'msr_sqa\', \'accuracy\': 0.6155}, \'description\': \'TAPAS small model fine-tuned on Sequential Question Answering (SQA). It uses relative position embeddings (i.e. resetting the position index at every cell of the table).\'}', metadata={})]


 We have a dataset related to coffee and tea prices. We need to answer a question on who sells hot chocolate and their prices.\n###Input: {\"table\": [[\"Shop\", \"Drink\", \"Price\"], [\"Cafe A\", \"Coffee\", \"3.00\"], [\"Cafe B\", \"Tea\", \"2.50\"], [\"Cafe C\", \"Hot Chocolate\", \"4.50\"], [\"Cafe D\", \"Hot Chocolate\", \"3.75\"]], \"queries\": [\"Which shops sell hot chocolate and what are their prices?\"]}\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-small-finetuned-sqa\', \'api_call\': "pipeline(\'table-question-answering\', model=\'google/tapas-small-finetuned-sqa\')", \'api_arguments\': \'\', \'python_environment_requirements\': \'transformers\', \'example_code\': \'\', \'performance\': {\'dataset\': \'msr_sqa\', \'accuracy\': 0.6155}, \'description\': \'TAPAS small model fine-tuned on Sequential Question Answering (SQA). It uses relative position embeddings (i.e. resetting the position index at every cell of the table).\'}', metadata={})]


 A company is running a survey and they want to know how many respondents have given a specific answer for each question of the survey.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Multimodal Document Question Answer\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Document Question Answering\', \'api_name\': \'CQI_Visual_Question_Awnser_PT_v0\', \'api_call\': "pipeline(\'question-answering\', model=LayoutLMForQuestionAnswering.from_pretrained(\'microsoft/layoutlm-base-uncased\'))", \'api_arguments\': [\'url\', \'question\'], \'python_environment_requirements\': [\'PIL\', \'pytesseract\', \'PyTorch\', \'transformers\'], \'example_code\': ["nlp(\'https://templates.invoicehome.com/invoice-template-us-neat-750px.png\', \'What is the invoice number?\')", "nlp(\'https://miro.medium.com/max/787/1*iECQRIiOGTmEFLdWkVIH2g.jpeg\', \'What is the purchase amount?\')", "nlp(\'https://www.accountingcoach.com/wp-content/uploads/2013/10/income-statement-example@2x.png\', \'What are the 2020 net sales?\')"], \'performance\': {\'dataset\': [{\'accuracy\': 0.9943977}, {\'accuracy\': 0.9912159}, {\'accuracy\': 0.59147286}]}, \'description\': \'A model for visual question answering in Portuguese and English, capable of processing PDFs and images to extract information and answer questions.\'}', metadata={})]


 Extract information about a non-compete clause from a legal document with a context related to data protection.\n###Input: \"The data protection provisions set forth in this agreement shall be in effect for a period of 2 years after the termination of services. The non-compete clause states that the service provider is prohibited from providing similar services to any competitor within a 50-mile radius and during the 1-year period following termination of services.\"\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Translation\', \'framework\': \'PyTorch Transformers\', \'functionality\': \'text2text-generation\', \'api_name\': \'facebook/nllb-200-distilled-600M\', \'api_call\': "pipeline(\'translation_xx_to_yy\', model=\'facebook/nllb-200-distilled-600M\')", \'api_arguments\': [\'model\', \'text\'], \'python_environment_requirements\': [\'transformers\', \'torch\'], \'example_code\': "from transformers import pipeline; translator = pipeline(\'translation_xx_to_yy\', model=\'facebook/nllb-200-distilled-600M\'); translator(\'Hello World\')", \'performance\': {\'dataset\': \'Flores-200\', \'accuracy\': \'BLEU, spBLEU, chrF++\'}, \'description\': \'NLLB-200 is a machine translation model primarily intended for research in machine translation, especially for low-resource languages. It allows for single sentence translation among 200 languages. The model was trained on general domain text data and is not intended to be used with domain specific texts, such as medical domain or legal domain. The model is not intended to be used for document translation.\'}', metadata={})]


 Tell me the day of the game when it was played given the following context: \"The game was played on February 7, 2016 at Levi's Stadium in the San Francisco Bay Area at Santa Clara, California.\"\n###Input: {'context': \"The game was played on February 7, 2016 at Levi's Stadium in the San Francisco Bay Area at Santa Clara, California.\", 'question': \"What day was the game played on?\"}\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Question Answering\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Question Answering\', \'api_name\': \'csarron/bert-base-uncased-squad-v1\', \'api_call\': "pipeline(\'question-answering\', model=\'csarron/bert-base-uncased-squad-v1\', tokenizer=\'csarron/bert-base-uncased-squad-v1\')", \'api_arguments\': {\'model\': \'csarron/bert-base-uncased-squad-v1\', \'tokenizer\': \'csarron/bert-base-uncased-squad-v1\'}, \'python_environment_requirements\': \'Python 3.7.5\', \'example_code\': "from transformers import pipeline\\nqa_pipeline = pipeline(\\n question-answering,\\n model=csarron/bert-base-uncased-squad-v1,\\n tokenizer=csarron/bert-base-uncased-squad-v1\\n)\\npredictions = qa_pipeline({\\n \'context\': The game was played on February 7, 2016 at Levi\'s Stadium in the San Francisco Bay Area at Santa Clara, California.,\\n \'question\': What day was the game played on?\\n})\\nprint(predictions)", \'performance\': {\'dataset\': \'SQuAD1.1\', \'accuracy\': {\'EM\': 80.9, \'F1\': 88.2}}, \'description\': \'BERT-base uncased model fine-tuned on SQuAD v1. This model is case-insensitive and does not make a difference between english and English.\'}', metadata={})]


 We need to identify the relationship between two sentences whether they are contradictory, entail each other, or neutral.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Sentence Similarity\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Sentence Embeddings\', \'api_name\': \'sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2\', \'api_call\': "SentenceTransformer(\'sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2\')", \'api_arguments\': [\'sentences\'], \'python_environment_requirements\': \'pip install -U sentence-transformers\', \'example_code\': "from sentence_transformers import SentenceTransformer\\nsentences = [This is an example sentence, Each sentence is converted]\\nmodel = SentenceTransformer(\'sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2\')\\nembeddings = model.encode(sentences)\\nprint(embeddings)", \'performance\': {\'dataset\': \'https://seb.sbert.net\', \'accuracy\': \'Automated evaluation\'}, \'description\': \'This is a sentence-transformers model: It maps sentences & paragraphs to a 384 dimensional dense vector space and can be used for tasks like clustering or semantic search.\'}', metadata={})]


 I am a climate change agency, looking to have my research summaries translated into Chinese for international audiences.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Summarization\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Text Summarization\', \'api_name\': \'Randeng-Pegasus-238M-Summary-Chinese\', \'api_call\': "PegasusForConditionalGeneration.from_pretrained(\'IDEA-CCNL/Randeng-Pegasus-238M-Summary-Chinese\')", \'api_arguments\': {\'text\': \'string\', \'max_length\': \'integer\'}, \'python_environment_requirements\': [\'transformers\', \'tokenizers_pegasus.py\', \'data_utils.py\'], \'example_code\': "from transformers import PegasusForConditionalGeneration\\nfrom tokenizers_pegasus import PegasusTokenizer\\nmodel = PegasusForConditionalGeneration.from_pretrained(\'IDEA-CCNL/Randeng-Pegasus-238M-Summary-Chinese\')\\ntokenizer = PegasusTokenizer.from_pretrained(\'IDEA-CCNL/Randeng-Pegasus-238M-Summary-Chinese\')\\ntext = \'1\'\\ninputs = tokenizer(text, max_length=1024, return_tensors=\'pt\')\\nsummary_ids = model.generate(inputs[\'input_ids\'])\\ntokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]", \'performance\': {\'dataset\': \'LCSTS\', \'accuracy\': {\'rouge-1\': 43.46, \'rouge-2\': 29.59, \'rouge-L\': 39.76}}, \'description\': \'Randeng-Pegasus-238M-Summary-Chinese is a Chinese text summarization model based on Pegasus. It is fine-tuned on 7 Chinese text summarization datasets including education, new2016zh, nlpcc, shence, sohu, thucnews, and weibo. The model can be used to generate summaries for Chinese text inputs.\'}', metadata={})]


 We are building an app to summarize long articles for users. We need a solution to create a condensed summary of the given text.\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={})]


 A news agency wants to summaries their international news articles daily.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text2Text Generation\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Summarization\', \'api_name\': \'it5-base-news-summarization\', \'api_call\': "pipeline(\'summarization\', model=\'it5/it5-base-news-summarization\')", \'api_arguments\': [\'text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'newsum(Dal 31 maggio è infine partita la piattaforma ITsART, a più di un anno da quando – durante il primo lockdown – il ministro della Cultura Dario Franceschini ne aveva parlato come di «una sorta di Netflix della cultura», pensata per «offrire a tutto il mondo la cultura italiana a pagamento». È presto per dare giudizi definitivi sulla piattaforma, e di certo sarà difficile farlo anche più avanti senza numeri precisi. Al momento, l’unica cosa che si può fare è guardare com’è fatto il sito, contare quanti contenuti ci sono (circa 700 “titoli”, tra film, documentari, spettacoli teatrali e musicali e altri eventi) e provare a dare un giudizio sul loro valore e sulla loro varietà. Intanto, una cosa notata da più parti è che diversi contenuti di ITsART sono a pagamento sulla piattaforma sebbene altrove, per esempio su RaiPlay, siano invece disponibili gratuitamente.)\', \'performance\': {\'dataset\': \'NewsSum-IT\', \'accuracy\': {\'Rouge1\': 0.339, \'Rouge2\': 0.16, \'RougeL\': 0.263}}, \'description\': \'IT5 Base model fine-tuned on news summarization on the Fanpage and Il Post corpora for Italian Language Understanding and Generation.\'}', metadata={})]


 Design a smart home system that can have conversations with the user for controlling the home appliances.\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 publishing company is developing a language comprehension program for elementary school students. They want a system that can generate a short story based on a given prompt.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Text Classification\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Paraphrase-based utterance augmentation\', \'api_name\': \'prithivida/parrot_fluency_model\', \'api_call\': "pipeline(\'text-classification\', model=\'prithivida/parrot_fluency_model\')", \'api_arguments\': \'text\', \'python_environment_requirements\': [\'transformers\'], \'example_code\': "parrot(\'your input text\')", \'performance\': {\'dataset\': \'N/A\', \'accuracy\': \'N/A\'}, \'description\': \'Parrot is a paraphrase-based utterance augmentation framework purpose-built to accelerate training NLU models. A paraphrase framework is more than just a paraphrasing model.\'}', metadata={})]


 Can you initiate a conversation with an AI model that plays the role of a friend who just got back from a conference?\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Conversational\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Text Generation\', \'api_name\': \'mywateriswet/ShuanBot\', \'api_call\': "pipeline(\'conversational\', model=\'mywateriswet/ShuanBot\')", \'api_arguments\': \'message\', \'python_environment_requirements\': \'transformers\', \'example_code\': "response = chatbot(\'What is your name?\')", \'performance\': {\'dataset\': \'N/A\', \'accuracy\': \'N/A\'}, \'description\': \'ShuanBot is a conversational chatbot model based on the GPT-2 architecture. It can be used for generating human-like responses in a chat context.\'}', metadata={})]


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


 Provide a short summary of an article about cryptocurrency investment risks.\n###Input: Cryptocurrencies have become exceedingly popular among investors seeking higher returns and diversification in their portfolios. However, investing in these digital currencies carries several inherent risks. Market volatility is a major factor \u2013 cryptocurrencies can experience wild price swings, sometimes even within hours or minutes. This high volatility makes it difficult to predict the future value of the investments and can result in significant losses. Furthermore, the lack of regulatory oversight and security concerns may also lead to potential frauds and hacks, exposing investors to additional risk. Lastly, the environmental impact of mining digital currencies like Bitcoin has come under scrutiny, questioning the long-term sustainability of the cryptocurrency market.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Summarization\', \'framework\': \'Hugging Face Transformers\', \'functionality\': \'Abstractive Russian Summarization\', \'api_name\': \'cointegrated/rut5-base-absum\', \'api_call\': "T5ForConditionalGeneration.from_pretrained(\'cointegrated/rut5-base-absum\')", \'api_arguments\': {\'n_words\': \'int\', \'compression\': \'float\', \'max_length\': \'int\', \'num_beams\': \'int\', \'do_sample\': \'bool\', \'repetition_penalty\': \'float\'}, \'python_environment_requirements\': {\'transformers\': \'latest\', \'torch\': \'latest\'}, \'example_code\': "import torch\\nfrom transformers import T5ForConditionalGeneration, T5Tokenizer\\nMODEL_NAME = \'cointegrated/rut5-base-absum\'\\nmodel = T5ForConditionalGeneration.from_pretrained(MODEL_NAME)\\ntokenizer = T5Tokenizer.from_pretrained(MODEL_NAME)\\nmodel.cuda();\\nmodel.eval();\\ndef summarize(\\n text, n_words=None, compression=None,\\n max_length=1000, num_beams=3, do_sample=False, repetition_penalty=10.0, \\n <strong>kwargs\\n):\\n \\n Summarize the text\\n The following parameters are mutually exclusive:\\n - n_words (int) is an approximate number of words to generate.\\n - compression (float) is an approximate length ratio of summary and original text.\\n \\n if n_words:\\n text = \'[{}] \'.format(n_words) + text\\n elif compression:\\n text = \'[{0:.1g}] \'.format(compression) + text\\n x = tokenizer(text, return_tensors=\'pt\', padding=True).to(model.device)\\n with torch.inference_mode():\\n out = model.generate(\\n </strong>x, \\n max_length=max_length, num_beams=num_beams, \\n do_sample=do_sample, repetition_penalty=repetition_penalty, \\n **kwargs\\n )\\n return tokenizer.decode(out[0], skip_special_tokens=True)", \'performance\': {\'dataset\': [\'csebuetnlp/xlsum\', \'IlyaGusev/gazeta\', \'mlsum\'], \'accuracy\': \'Not provided\'}, \'description\': \'This is a model for abstractive Russian summarization, based on cointegrated/rut5-base-multitask and fine-tuned on 4 datasets.\'}', metadata={})]


 You have just met a person that speaks French. As a hotel manager, you need to tell them, \"Welcome to our hotel, we hope you enjoy your stay.\" in French.\n
 Use this API documentation for reference: [Document(page_content='{\'domain\': \'Natural Language Processing Translation\', \'framework\': \'Hugging Face\', \'functionality\': \'Translation\', \'api_name\': \'Helsinki-NLP/opus-mt-en-fr\', \'api_call\': "translate(\'input_text\', model=\'Helsinki-NLP/opus-mt-en-fr\')", \'api_arguments\': [\'input_text\'], \'python_environment_requirements\': [\'transformers\'], \'example_code\': \'\', \'performance\': {\'dataset\': \'opus\', \'accuracy\': {\'BLEU\': {\'newsdiscussdev2015-enfr.en.fr\': 33.8, \'newsdiscusstest2015-enfr.en.fr\': 40.0, \'newssyscomb2009.en.fr\': 29.8, \'news-test2008.en.fr\': 27.5, \'newstest2009.en.fr\': 29.4, \'newstest2010.en.fr\': 32.7, \'newstest2011.en.fr\': 34.3, \'newstest2012.en.fr\': 31.8, \'newstest2013.en.fr\': 33.2, \'Tatoeba.en.fr\': 50.5}}}, \'description\': \'Helsinki-NLP/opus-mt-en-fr is a translation model that translates English text to French using the Hugging Face Transformers library. It is based on the OPUS dataset and uses a transformer-align architecture with normalization and SentencePiece pre-processing.\'}', metadata={})]


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